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

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedValueXY.js

@@ -0,0 +1,191 @@
+/**
+ * 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.default = void 0;
+var _AnimatedValue = _interopRequireDefault(require("./AnimatedValue"));
+var _AnimatedWithChildren = _interopRequireDefault(require("./AnimatedWithChildren"));
+var _invariant = _interopRequireDefault(require("fbjs/lib/invariant"));
+var _uniqueId = 1;
+
+/**
+ * 2D Value for driving 2D animations, such as pan gestures. Almost identical
+ * API to normal `Animated.Value`, but multiplexed.
+ *
+ * See https://reactnative.dev/docs/animatedvaluexy.html
+ */
+class AnimatedValueXY extends _AnimatedWithChildren.default {
+  constructor(valueIn) {
+    super();
+    var value = valueIn || {
+      x: 0,
+      y: 0
+    }; // fixme: shouldn't need `: any`
+    if (typeof value.x === 'number' && typeof value.y === 'number') {
+      this.x = new _AnimatedValue.default(value.x);
+      this.y = new _AnimatedValue.default(value.y);
+    } else {
+      (0, _invariant.default)(value.x instanceof _AnimatedValue.default && value.y instanceof _AnimatedValue.default, 'AnimatedValueXY must be initialized with an object of numbers or ' + 'AnimatedValues.');
+      this.x = value.x;
+      this.y = value.y;
+    }
+    this._listeners = {};
+  }
+
+  /**
+   * Directly set the value. This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#setvalue
+   */
+  setValue(value) {
+    this.x.setValue(value.x);
+    this.y.setValue(value.y);
+  }
+
+  /**
+   * Sets an offset that is applied on top of whatever value is set, whether
+   * via `setValue`, an animation, or `Animated.event`. Useful for compensating
+   * things like the start of a pan gesture.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#setoffset
+   */
+  setOffset(offset) {
+    this.x.setOffset(offset.x);
+    this.y.setOffset(offset.y);
+  }
+
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#flattenoffset
+   */
+  flattenOffset() {
+    this.x.flattenOffset();
+    this.y.flattenOffset();
+  }
+
+  /**
+   * Sets the offset value to the base value, and resets the base value to
+   * zero. The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#extractoffset
+   */
+  extractOffset() {
+    this.x.extractOffset();
+    this.y.extractOffset();
+  }
+  __getValue() {
+    return {
+      x: this.x.__getValue(),
+      y: this.y.__getValue()
+    };
+  }
+
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#resetanimation
+   */
+  resetAnimation(callback) {
+    this.x.resetAnimation();
+    this.y.resetAnimation();
+    callback && callback(this.__getValue());
+  }
+
+  /**
+   * Stops any running animation or tracking. `callback` is invoked with the
+   * final value after stopping the animation, which is useful for updating
+   * state to match the animation position with layout.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#stopanimation
+   */
+  stopAnimation(callback) {
+    this.x.stopAnimation();
+    this.y.stopAnimation();
+    callback && callback(this.__getValue());
+  }
+
+  /**
+   * Adds an asynchronous listener to the value so you can observe updates from
+   * animations.  This is useful because there is no way to synchronously read
+   * the value because it might be driven natively.
+   *
+   * Returns a string that serves as an identifier for the listener.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#addlistener
+   */
+  addListener(callback) {
+    var id = String(_uniqueId++);
+    var jointCallback = _ref => {
+      var number = _ref.value;
+      callback(this.__getValue());
+    };
+    this._listeners[id] = {
+      x: this.x.addListener(jointCallback),
+      y: this.y.addListener(jointCallback)
+    };
+    return id;
+  }
+
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#removelistener
+   */
+  removeListener(id) {
+    this.x.removeListener(this._listeners[id].x);
+    this.y.removeListener(this._listeners[id].y);
+    delete this._listeners[id];
+  }
+
+  /**
+   * Remove all registered listeners.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#removealllisteners
+   */
+  removeAllListeners() {
+    this.x.removeAllListeners();
+    this.y.removeAllListeners();
+    this._listeners = {};
+  }
+
+  /**
+   * Converts `{x, y}` into `{left, top}` for use in style.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#getlayout
+   */
+  getLayout() {
+    return {
+      left: this.x,
+      top: this.y
+    };
+  }
+
+  /**
+   * Converts `{x, y}` into a useable translation transform.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#gettranslatetransform
+   */
+  getTranslateTransform() {
+    return [{
+      translateX: this.x
+    }, {
+      translateY: this.y
+    }];
+  }
+}
+var _default = exports.default = AnimatedValueXY;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedWithChildren.js

@@ -0,0 +1,77 @@
+/**
+ * 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.default = void 0;
+var _createForOfIteratorHelperLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelperLoose"));
+var _AnimatedNode = _interopRequireDefault(require("./AnimatedNode"));
+var _NativeAnimatedHelper = _interopRequireDefault(require("../NativeAnimatedHelper"));
+class AnimatedWithChildren extends _AnimatedNode.default {
+  constructor() {
+    super();
+    this._children = [];
+  }
+  __makeNative(platformConfig) {
+    if (!this.__isNative) {
+      this.__isNative = true;
+      for (var _iterator = (0, _createForOfIteratorHelperLoose2.default)(this._children), _step; !(_step = _iterator()).done;) {
+        var child = _step.value;
+        child.__makeNative(platformConfig);
+        _NativeAnimatedHelper.default.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+      }
+    }
+    super.__makeNative(platformConfig);
+  }
+  __addChild(child) {
+    if (this._children.length === 0) {
+      this.__attach();
+    }
+    this._children.push(child);
+    if (this.__isNative) {
+      // Only accept "native" animated nodes as children
+      child.__makeNative(this.__getPlatformConfig());
+      _NativeAnimatedHelper.default.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+    }
+  }
+  __removeChild(child) {
+    var index = this._children.indexOf(child);
+    if (index === -1) {
+      console.warn("Trying to remove a child that doesn't exist");
+      return;
+    }
+    if (this.__isNative && child.__isNative) {
+      _NativeAnimatedHelper.default.API.disconnectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+    }
+    this._children.splice(index, 1);
+    if (this._children.length === 0) {
+      this.__detach();
+    }
+  }
+  __getChildren() {
+    return this._children;
+  }
+  __callListeners(value) {
+    super.__callListeners(value);
+    if (!this.__isNative) {
+      for (var _iterator2 = (0, _createForOfIteratorHelperLoose2.default)(this._children), _step2; !(_step2 = _iterator2()).done;) {
+        var child = _step2.value;
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+        if (child.__getValue) {
+          child.__callListeners(child.__getValue());
+        }
+      }
+    }
+  }
+}
+var _default = exports.default = AnimatedWithChildren;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Animated/useAnimatedProps.js

@@ -0,0 +1,158 @@
+/**
+ * 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.default = useAnimatedProps;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _AnimatedProps = _interopRequireDefault(require("./nodes/AnimatedProps"));
+var _AnimatedEvent = require("./AnimatedEvent");
+var _useRefEffect = _interopRequireDefault(require("../Utilities/useRefEffect"));
+var _NativeAnimatedHelper = _interopRequireDefault(require("./NativeAnimatedHelper"));
+var _react = require("react");
+var _useLayoutEffect = _interopRequireDefault(require("../../../modules/useLayoutEffect"));
+function useAnimatedProps(props) {
+  var _useReducer = (0, _react.useReducer)(count => count + 1, 0),
+    scheduleUpdate = _useReducer[1];
+  var onUpdateRef = (0, _react.useRef)(null);
+
+  // TODO: Only invalidate `node` if animated props or `style` change. In the
+  // previous implementation, we permitted `style` to override props with the
+  // same name property name as styles, so we can probably continue doing that.
+  // The ordering of other props *should* not matter.
+  var node = (0, _react.useMemo)(() => new _AnimatedProps.default(props, () => onUpdateRef.current == null ? void 0 : onUpdateRef.current()), [props]);
+  useAnimatedPropsLifecycle(node);
+
+  // TODO: This "effect" does three things:
+  //
+  //   1) Call `setNativeView`.
+  //   2) Update `onUpdateRef`.
+  //   3) Update listeners for `AnimatedEvent` props.
+  //
+  // Ideally, each of these would be separat "effects" so that they are not
+  // unnecessarily re-run when irrelevant dependencies change. For example, we
+  // should be able to hoist all `AnimatedEvent` props and only do #3 if either
+  // the `AnimatedEvent` props change or `instance` changes.
+  //
+  // But there is no way to transparently compose three separate callback refs,
+  // so we just combine them all into one for now.
+  var refEffect = (0, _react.useCallback)(instance => {
+    // NOTE: This may be called more often than necessary (e.g. when `props`
+    // changes), but `setNativeView` already optimizes for that.
+    node.setNativeView(instance);
+
+    // NOTE: This callback is only used by the JavaScript animation driver.
+    onUpdateRef.current = () => {
+      // Schedule an update for this component to update `reducedProps`,
+      // but do not compute it immediately. If a parent also updated, we
+      // need to merge those new props in before updating.
+      scheduleUpdate();
+    };
+    var target = getEventTarget(instance);
+    var events = [];
+    for (var propName in props) {
+      var propValue = props[propName];
+      if (propValue instanceof _AnimatedEvent.AnimatedEvent && propValue.__isNative) {
+        propValue.__attach(target, propName);
+        events.push([propName, propValue]);
+      }
+    }
+    return () => {
+      onUpdateRef.current = null;
+      for (var _i = 0, _events = events; _i < _events.length; _i++) {
+        var _events$_i = _events[_i],
+          _propName = _events$_i[0],
+          _propValue = _events$_i[1];
+        _propValue.__detach(target, _propName);
+      }
+    };
+  }, [props, node]);
+  var callbackRef = (0, _useRefEffect.default)(refEffect);
+  return [reduceAnimatedProps(node), callbackRef];
+}
+function reduceAnimatedProps(node) {
+  // Force `collapsable` to be false so that the native view is not flattened.
+  // Flattened views cannot be accurately referenced by the native driver.
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, node.__getValue()), {}, {
+    collapsable: false
+  });
+}
+
+/**
+ * Manages the lifecycle of the supplied `AnimatedProps` by invoking `__attach`
+ * and `__detach`. However, this is more complicated because `AnimatedProps`
+ * uses reference counting to determine when to recursively detach its children
+ * nodes. So in order to optimize this, we avoid detaching until the next attach
+ * unless we are unmounting.
+ */
+function useAnimatedPropsLifecycle(node) {
+  var prevNodeRef = (0, _react.useRef)(null);
+  var isUnmountingRef = (0, _react.useRef)(false);
+  (0, _react.useEffect)(() => {
+    // It is ok for multiple components to call `flushQueue` because it noops
+    // if the queue is empty. When multiple animated components are mounted at
+    // the same time. Only first component flushes the queue and the others will noop.
+    _NativeAnimatedHelper.default.API.flushQueue();
+  });
+  (0, _useLayoutEffect.default)(() => {
+    isUnmountingRef.current = false;
+    return () => {
+      isUnmountingRef.current = true;
+    };
+  }, []);
+  (0, _useLayoutEffect.default)(() => {
+    node.__attach();
+    if (prevNodeRef.current != null) {
+      var prevNode = prevNodeRef.current;
+      // TODO: Stop restoring default values (unless `reset` is called).
+      prevNode.__restoreDefaultValues();
+      prevNode.__detach();
+      prevNodeRef.current = null;
+    }
+    return () => {
+      if (isUnmountingRef.current) {
+        // NOTE: Do not restore default values on unmount, see D18197735.
+        node.__detach();
+      } else {
+        prevNodeRef.current = node;
+      }
+    };
+  }, [node]);
+}
+function getEventTarget(instance) {
+  return typeof instance === 'object' && typeof (instance == null ? void 0 : instance.getScrollableNode) === 'function' ?
+  // $FlowFixMe[incompatible-use] - Legacy instance assumptions.
+  instance.getScrollableNode() : instance;
+}
+
+// $FlowFixMe[unclear-type] - Legacy instance assumptions.
+function isFabricInstance(instance) {
+  var _instance$getScrollRe;
+  return hasFabricHandle(instance) ||
+  // Some components have a setNativeProps function but aren't a host component
+  // such as lists like FlatList and SectionList. These should also use
+  // forceUpdate in Fabric since setNativeProps doesn't exist on the underlying
+  // host component. This crazy hack is essentially special casing those lists and
+  // ScrollView itself to use forceUpdate in Fabric.
+  // If these components end up using forwardRef then these hacks can go away
+  // as instance would actually be the underlying host component and the above check
+  // would be sufficient.
+  hasFabricHandle(instance == null || instance.getNativeScrollRef == null ? void 0 : instance.getNativeScrollRef()) || hasFabricHandle(instance == null || instance.getScrollResponder == null || (_instance$getScrollRe = instance.getScrollResponder()) == null || _instance$getScrollRe.getNativeScrollRef == null ? void 0 : _instance$getScrollRe.getNativeScrollRef());
+}
+
+// $FlowFixMe[unclear-type] - Legacy instance assumptions.
+function hasFabricHandle(instance) {
+  var _instance$_internalIn;
+  // eslint-disable-next-line dot-notation
+  return (instance == null || (_instance$_internalIn = instance['_internalInstanceHandle']) == null || (_instance$_internalIn = _instance$_internalIn.stateNode) == null ? void 0 : _instance$_internalIn.canonical) != null;
+}
+module.exports = exports.default;

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

@@ -0,0 +1,82 @@
+/**
+ * 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.default = void 0;
+var _InteractionManager = _interopRequireDefault(require("../../../exports/InteractionManager"));
+/**
+ * A simple class for batching up invocations of a low-pri callback. A timeout is set to run the
+ * callback once after a delay, no matter how many times it's scheduled. Once the delay is reached,
+ * InteractionManager.runAfterInteractions is used to invoke the callback after any hi-pri
+ * interactions are done running.
+ *
+ * Make sure to cleanup with dispose().  Example:
+ *
+ *   class Widget extends React.Component {
+ *     _batchedSave: new Batchinator(() => this._saveState, 1000);
+ *     _saveSate() {
+ *       // save this.state to disk
+ *     }
+ *     componentDidUpdate() {
+ *       this._batchedSave.schedule();
+ *     }
+ *     componentWillUnmount() {
+ *       this._batchedSave.dispose();
+ *     }
+ *     ...
+ *   }
+ */
+class Batchinator {
+  constructor(callback, delayMS) {
+    this._delay = delayMS;
+    this._callback = callback;
+  }
+  /*
+   * Cleanup any pending tasks.
+   *
+   * By default, if there is a pending task the callback is run immediately. Set the option abort to
+   * true to not call the callback if it was pending.
+   */
+  dispose(options) {
+    if (options === void 0) {
+      options = {
+        abort: false
+      };
+    }
+    if (this._taskHandle) {
+      this._taskHandle.cancel();
+      if (!options.abort) {
+        this._callback();
+      }
+      this._taskHandle = null;
+    }
+  }
+  schedule() {
+    if (this._taskHandle) {
+      return;
+    }
+    var timeoutHandle = setTimeout(() => {
+      this._taskHandle = _InteractionManager.default.runAfterInteractions(() => {
+        // Note that we clear the handle before invoking the callback so that if the callback calls
+        // schedule again, it will actually schedule another task.
+        this._taskHandle = null;
+        this._callback();
+      });
+    }, this._delay);
+    this._taskHandle = {
+      cancel: () => clearTimeout(timeoutHandle)
+    };
+  }
+}
+var _default = exports.default = Batchinator;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/EventEmitter/NativeEventEmitter.js

@@ -0,0 +1,85 @@
+/**
+ * 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.default = void 0;
+var _Platform = _interopRequireDefault(require("../../../exports/Platform"));
+var _RCTDeviceEventEmitter = _interopRequireDefault(require("./RCTDeviceEventEmitter"));
+var _invariant = _interopRequireDefault(require("fbjs/lib/invariant"));
+/**
+ * `NativeEventEmitter` is intended for use by Native Modules to emit events to
+ * JavaScript listeners. If a `NativeModule` is supplied to the constructor, it
+ * will be notified (via `addListener` and `removeListeners`) when the listener
+ * count changes to manage "native memory".
+ *
+ * Currently, all native events are fired via a global `RCTDeviceEventEmitter`.
+ * This means event names must be globally unique, and it means that call sites
+ * can theoretically listen to `RCTDeviceEventEmitter` (although discouraged).
+ */
+class NativeEventEmitter {
+  constructor(nativeModule) {
+    if (_Platform.default.OS === 'ios' || _Platform.default.OS === 'web') {
+      // Avoiding this check for web as there are 3rd party modules for web which are failing for this
+      if (_Platform.default.OS === 'ios') {
+        (0, _invariant.default)(nativeModule != null, '`new NativeEventEmitter()` requires a non-null argument.');
+      }
+      this._nativeModule = nativeModule;
+    }
+  }
+  addListener(eventType, listener, context) {
+    var _this$_nativeModule;
+    (_this$_nativeModule = this._nativeModule) == null || _this$_nativeModule.addListener(eventType);
+    var subscription = _RCTDeviceEventEmitter.default.addListener(eventType, listener, context);
+    return {
+      remove: () => {
+        if (subscription != null) {
+          var _this$_nativeModule2;
+          (_this$_nativeModule2 = this._nativeModule) == null || _this$_nativeModule2.removeListeners(1);
+          // $FlowFixMe[incompatible-use]
+          subscription.remove();
+          subscription = null;
+        }
+      }
+    };
+  }
+
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+  removeListener(eventType, listener) {
+    var _this$_nativeModule3;
+    (_this$_nativeModule3 = this._nativeModule) == null || _this$_nativeModule3.removeListeners(1);
+    // NOTE: This will report a deprecation notice via `console.error`.
+    // $FlowFixMe[prop-missing] - `removeListener` exists but is deprecated.
+    _RCTDeviceEventEmitter.default.removeListener(eventType, listener);
+  }
+  emit(eventType) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    // Generally, `RCTDeviceEventEmitter` is directly invoked. But this is
+    // included for completeness.
+    _RCTDeviceEventEmitter.default.emit(eventType, ...args);
+  }
+  removeAllListeners(eventType) {
+    var _this$_nativeModule4;
+    (0, _invariant.default)(eventType != null, '`NativeEventEmitter.removeAllListener()` requires a non-null argument.');
+    (_this$_nativeModule4 = this._nativeModule) == null || _this$_nativeModule4.removeListeners(this.listenerCount(eventType));
+    _RCTDeviceEventEmitter.default.removeAllListeners(eventType);
+  }
+  listenerCount(eventType) {
+    return _RCTDeviceEventEmitter.default.listenerCount(eventType);
+  }
+}
+exports.default = NativeEventEmitter;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/EventEmitter/RCTDeviceEventEmitter.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _EventEmitter = _interopRequireDefault(require("../vendor/emitter/EventEmitter"));
+/**
+ * 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
+ */
+// FIXME: use typed events
+/**
+ * Global EventEmitter used by the native platform to emit events to JavaScript.
+ * Events are identified by globally unique event names.
+ *
+ * NativeModules that emit events should instead subclass `NativeEventEmitter`.
+ */
+var _default = exports.default = new _EventEmitter.default();
+module.exports = exports.default;