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

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

@@ -0,0 +1,128 @@
+/**
+ * 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 _AnimatedNode = _interopRequireDefault(require("./AnimatedNode"));
+var _AnimatedTransform = _interopRequireDefault(require("./AnimatedTransform"));
+var _AnimatedWithChildren = _interopRequireDefault(require("./AnimatedWithChildren"));
+var _NativeAnimatedHelper = _interopRequireDefault(require("../NativeAnimatedHelper"));
+var _StyleSheet = _interopRequireDefault(require("../../../../exports/StyleSheet"));
+var flattenStyle = _StyleSheet.default.flatten;
+function createAnimatedStyle(inputStyle) {
+  var style = flattenStyle(inputStyle);
+  var animatedStyles = {};
+  for (var key in style) {
+    var value = style[key];
+    if (key === 'transform' && Array.isArray(value)) {
+      animatedStyles[key] = new _AnimatedTransform.default(value);
+    } else if (value instanceof _AnimatedNode.default) {
+      animatedStyles[key] = value;
+    } else if (value && !Array.isArray(value) && typeof value === 'object') {
+      animatedStyles[key] = createAnimatedStyle(value);
+    }
+  }
+  return animatedStyles;
+}
+class AnimatedStyle extends _AnimatedWithChildren.default {
+  constructor(style) {
+    super();
+    this._inputStyle = style;
+    this._style = createAnimatedStyle(style);
+  }
+
+  // Recursively get values for nested styles (like iOS's shadowOffset)
+  _walkStyleAndGetValues(style) {
+    var updatedStyle = {};
+    for (var key in style) {
+      var value = style[key];
+      if (value instanceof _AnimatedNode.default) {
+        if (!value.__isNative) {
+          // We cannot use value of natively driven nodes this way as the value we have access from
+          // JS may not be up to date.
+          updatedStyle[key] = value.__getValue();
+        }
+      } else if (value && !Array.isArray(value) && typeof value === 'object') {
+        // Support animating nested values (for example: shadowOffset.height)
+        updatedStyle[key] = this._walkStyleAndGetValues(value);
+      } else {
+        updatedStyle[key] = value;
+      }
+    }
+    return updatedStyle;
+  }
+  __getValue() {
+    return [this._inputStyle, this._walkStyleAndGetValues(this._style)];
+  }
+
+  // Recursively get animated values for nested styles (like iOS's shadowOffset)
+  _walkStyleAndGetAnimatedValues(style) {
+    var updatedStyle = {};
+    for (var key in style) {
+      var value = style[key];
+      if (value instanceof _AnimatedNode.default) {
+        updatedStyle[key] = value.__getAnimatedValue();
+      } else if (value && !Array.isArray(value) && typeof value === 'object') {
+        // Support animating nested values (for example: shadowOffset.height)
+        updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value);
+      }
+    }
+    return updatedStyle;
+  }
+  __getAnimatedValue() {
+    return this._walkStyleAndGetAnimatedValues(this._style);
+  }
+  __attach() {
+    for (var key in this._style) {
+      var value = this._style[key];
+      if (value instanceof _AnimatedNode.default) {
+        value.__addChild(this);
+      }
+    }
+  }
+  __detach() {
+    for (var key in this._style) {
+      var value = this._style[key];
+      if (value instanceof _AnimatedNode.default) {
+        value.__removeChild(this);
+      }
+    }
+    super.__detach();
+  }
+  __makeNative() {
+    for (var key in this._style) {
+      var value = this._style[key];
+      if (value instanceof _AnimatedNode.default) {
+        value.__makeNative();
+      }
+    }
+    super.__makeNative();
+  }
+  __getNativeConfig() {
+    var styleConfig = {};
+    for (var styleKey in this._style) {
+      if (this._style[styleKey] instanceof _AnimatedNode.default) {
+        var style = this._style[styleKey];
+        style.__makeNative();
+        styleConfig[styleKey] = style.__getNativeTag();
+      }
+    }
+    _NativeAnimatedHelper.default.validateStyles(styleConfig);
+    return {
+      type: 'style',
+      style: styleConfig
+    };
+  }
+}
+var _default = exports.default = AnimatedStyle;
+module.exports = exports.default;

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

@@ -0,0 +1,53 @@
+/**
+ * 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 _AnimatedInterpolation = _interopRequireDefault(require("./AnimatedInterpolation"));
+var _AnimatedValue = _interopRequireDefault(require("./AnimatedValue"));
+var _AnimatedWithChildren = _interopRequireDefault(require("./AnimatedWithChildren"));
+class AnimatedSubtraction extends _AnimatedWithChildren.default {
+  constructor(a, b) {
+    super();
+    this._a = typeof a === 'number' ? new _AnimatedValue.default(a) : a;
+    this._b = typeof b === 'number' ? new _AnimatedValue.default(b) : b;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig);
+    this._b.__makeNative(platformConfig);
+    super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return this._a.__getValue() - this._b.__getValue();
+  }
+  interpolate(config) {
+    return new _AnimatedInterpolation.default(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: 'subtraction',
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var _default = exports.default = AnimatedSubtraction;
+module.exports = exports.default;

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

@@ -0,0 +1,76 @@
+/**
+ * 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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _AnimatedValue = _interopRequireDefault(require("./AnimatedValue"));
+var _AnimatedNode = _interopRequireDefault(require("./AnimatedNode"));
+var _NativeAnimatedHelper = require("../NativeAnimatedHelper");
+class AnimatedTracking extends _AnimatedNode.default {
+  constructor(value, parent, animationClass, animationConfig, callback) {
+    super();
+    this._value = value;
+    this._parent = parent;
+    this._animationClass = animationClass;
+    this._animationConfig = animationConfig;
+    this._useNativeDriver = (0, _NativeAnimatedHelper.shouldUseNativeDriver)(animationConfig);
+    this._callback = callback;
+    this.__attach();
+  }
+  __makeNative() {
+    this.__isNative = true;
+    this._parent.__makeNative();
+    super.__makeNative();
+    this._value.__makeNative();
+  }
+  __getValue() {
+    return this._parent.__getValue();
+  }
+  __attach() {
+    this._parent.__addChild(this);
+    if (this._useNativeDriver) {
+      // when the tracking starts we need to convert this node to a "native node"
+      // so that the parent node will be made "native" too. This is necessary as
+      // if we don't do this `update` method will get called. At that point it
+      // may be too late as it would mean the JS driver has already started
+      // updating node values
+      this.__makeNative();
+    }
+  }
+  __detach() {
+    this._parent.__removeChild(this);
+    super.__detach();
+  }
+  update() {
+    this._value.animate(new this._animationClass((0, _objectSpread2.default)((0, _objectSpread2.default)({}, this._animationConfig), {}, {
+      toValue: this._animationConfig.toValue.__getValue()
+    })), this._callback);
+  }
+  __getNativeConfig() {
+    var animation = new this._animationClass((0, _objectSpread2.default)((0, _objectSpread2.default)({}, this._animationConfig), {}, {
+      // remove toValue from the config as it's a ref to Animated.Value
+      toValue: undefined
+    }));
+    var animationConfig = animation.__getNativeAnimationConfig();
+    return {
+      type: 'tracking',
+      animationId: (0, _NativeAnimatedHelper.generateNewAnimationId)(),
+      animationConfig,
+      toValue: this._parent.__getNativeTag(),
+      value: this._value.__getNativeTag()
+    };
+  }
+}
+var _default = exports.default = AnimatedTracking;
+module.exports = exports.default;

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

@@ -0,0 +1,113 @@
+/**
+ * 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 _AnimatedNode = _interopRequireDefault(require("./AnimatedNode"));
+var _AnimatedWithChildren = _interopRequireDefault(require("./AnimatedWithChildren"));
+var _NativeAnimatedHelper = _interopRequireDefault(require("../NativeAnimatedHelper"));
+class AnimatedTransform extends _AnimatedWithChildren.default {
+  constructor(transforms) {
+    super();
+    this._transforms = transforms;
+  }
+  __makeNative() {
+    this._transforms.forEach(transform => {
+      for (var key in transform) {
+        var value = transform[key];
+        if (value instanceof _AnimatedNode.default) {
+          value.__makeNative();
+        }
+      }
+    });
+    super.__makeNative();
+  }
+  __getValue() {
+    return this._transforms.map(transform => {
+      var result = {};
+      for (var key in transform) {
+        var value = transform[key];
+        if (value instanceof _AnimatedNode.default) {
+          result[key] = value.__getValue();
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+  __getAnimatedValue() {
+    return this._transforms.map(transform => {
+      var result = {};
+      for (var key in transform) {
+        var value = transform[key];
+        if (value instanceof _AnimatedNode.default) {
+          result[key] = value.__getAnimatedValue();
+        } else {
+          // All transform components needed to recompose matrix
+          result[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+  __attach() {
+    this._transforms.forEach(transform => {
+      for (var key in transform) {
+        var value = transform[key];
+        if (value instanceof _AnimatedNode.default) {
+          value.__addChild(this);
+        }
+      }
+    });
+  }
+  __detach() {
+    this._transforms.forEach(transform => {
+      for (var key in transform) {
+        var value = transform[key];
+        if (value instanceof _AnimatedNode.default) {
+          value.__removeChild(this);
+        }
+      }
+    });
+    super.__detach();
+  }
+  __getNativeConfig() {
+    var transConfigs = [];
+    this._transforms.forEach(transform => {
+      for (var key in transform) {
+        var value = transform[key];
+        if (value instanceof _AnimatedNode.default) {
+          transConfigs.push({
+            type: 'animated',
+            property: key,
+            nodeTag: value.__getNativeTag()
+          });
+        } else {
+          transConfigs.push({
+            type: 'static',
+            property: key,
+            value: _NativeAnimatedHelper.default.transformDataType(value)
+          });
+        }
+      }
+    });
+    _NativeAnimatedHelper.default.validateTransform(transConfigs);
+    return {
+      type: 'transform',
+      transforms: transConfigs
+    };
+  }
+}
+var _default = exports.default = AnimatedTransform;
+module.exports = exports.default;

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

@@ -0,0 +1,271 @@
+/**
+ * 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 _AnimatedInterpolation = _interopRequireDefault(require("./AnimatedInterpolation"));
+var _AnimatedWithChildren = _interopRequireDefault(require("./AnimatedWithChildren"));
+var _InteractionManager = _interopRequireDefault(require("../../../../exports/InteractionManager"));
+var _NativeAnimatedHelper = _interopRequireDefault(require("../NativeAnimatedHelper"));
+var NativeAnimatedAPI = _NativeAnimatedHelper.default.API;
+
+/**
+ * Animated works by building a directed acyclic graph of dependencies
+ * transparently when you render your Animated components.
+ *
+ *               new Animated.Value(0)
+ *     .interpolate()        .interpolate()    new Animated.Value(1)
+ *         opacity               translateY      scale
+ *          style                         transform
+ *         View#234                         style
+ *                                         View#123
+ *
+ * A) Top Down phase
+ * When an Animated.Value is updated, we recursively go down through this
+ * graph in order to find leaf nodes: the views that we flag as needing
+ * an update.
+ *
+ * B) Bottom Up phase
+ * When a view is flagged as needing an update, we recursively go back up
+ * in order to build the new value that it needs. The reason why we need
+ * this two-phases process is to deal with composite props such as
+ * transform which can receive values from multiple parents.
+ */
+function _flush(rootNode) {
+  var animatedStyles = new Set();
+  function findAnimatedStyles(node) {
+    /* $FlowFixMe[prop-missing] (>=0.68.0 site=react_native_fb) This comment
+     * suppresses an error found when Flow v0.68 was deployed. To see the error
+     * delete this comment and run Flow. */
+    if (typeof node.update === 'function') {
+      animatedStyles.add(node);
+    } else {
+      node.__getChildren().forEach(findAnimatedStyles);
+    }
+  }
+  findAnimatedStyles(rootNode);
+  // $FlowFixMe[prop-missing]
+  animatedStyles.forEach(animatedStyle => animatedStyle.update());
+}
+
+/**
+ * Some operations are executed only on batch end, which is _mostly_ scheduled when
+ * Animated component props change. For some of the changes which require immediate execution
+ * (e.g. setValue), we create a separate batch in case none is scheduled.
+ */
+function _executeAsAnimatedBatch(id, operation) {
+  NativeAnimatedAPI.setWaitingForIdentifier(id);
+  operation();
+  NativeAnimatedAPI.unsetWaitingForIdentifier(id);
+}
+
+/**
+ * Standard value for driving animations.  One `Animated.Value` can drive
+ * multiple properties in a synchronized fashion, but can only be driven by one
+ * mechanism at a time.  Using a new mechanism (e.g. starting a new animation,
+ * or calling `setValue`) will stop any previous ones.
+ *
+ * See https://reactnative.dev/docs/animatedvalue
+ */
+class AnimatedValue extends _AnimatedWithChildren.default {
+  constructor(value, config) {
+    super();
+    if (typeof value !== 'number') {
+      throw new Error('AnimatedValue: Attempting to set value to undefined');
+    }
+    this._startingValue = this._value = value;
+    this._offset = 0;
+    this._animation = null;
+    if (config && config.useNativeDriver) {
+      this.__makeNative();
+    }
+  }
+  __detach() {
+    if (this.__isNative) {
+      NativeAnimatedAPI.getValue(this.__getNativeTag(), value => {
+        this._value = value - this._offset;
+      });
+    }
+    this.stopAnimation();
+    super.__detach();
+  }
+  __getValue() {
+    return this._value + this._offset;
+  }
+
+  /**
+   * Directly set the value.  This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setvalue
+   */
+  setValue(value) {
+    if (this._animation) {
+      this._animation.stop();
+      this._animation = null;
+    }
+    this._updateValue(value, !this.__isNative /* don't perform a flush for natively driven values */);
+    if (this.__isNative) {
+      _executeAsAnimatedBatch(this.__getNativeTag().toString(), () => NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value));
+    }
+  }
+
+  /**
+   * 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/animatedvalue#setoffset
+   */
+  setOffset(offset) {
+    this._offset = offset;
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(), offset);
+    }
+  }
+
+  /**
+   * 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/animatedvalue#flattenoffset
+   */
+  flattenOffset() {
+    this._value += this._offset;
+    this._offset = 0;
+    if (this.__isNative) {
+      NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+
+  /**
+   * 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/animatedvalue#extractoffset
+   */
+  extractOffset() {
+    this._offset += this._value;
+    this._value = 0;
+    if (this.__isNative) {
+      NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+
+  /**
+   * 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/animatedvalue#stopanimation
+   */
+  stopAnimation(callback) {
+    this.stopTracking();
+    this._animation && this._animation.stop();
+    this._animation = null;
+    if (callback) {
+      if (this.__isNative) {
+        NativeAnimatedAPI.getValue(this.__getNativeTag(), callback);
+      } else {
+        callback(this.__getValue());
+      }
+    }
+  }
+
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#resetanimation
+   */
+  resetAnimation(callback) {
+    this.stopAnimation(callback);
+    this._value = this._startingValue;
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), this._startingValue);
+    }
+  }
+  __onAnimatedValueUpdateReceived(value) {
+    this._updateValue(value, false /*flush*/);
+  }
+
+  /**
+   * Interpolates the value before updating the property, e.g. mapping 0-1 to
+   * 0-10.
+   */
+  interpolate(config) {
+    return new _AnimatedInterpolation.default(this, config);
+  }
+
+  /**
+   * Typically only used internally, but could be used by a custom Animation
+   * class.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#animate
+   */
+  animate(animation, callback) {
+    var handle = null;
+    if (animation.__isInteraction) {
+      handle = _InteractionManager.default.createInteractionHandle();
+    }
+    var previousAnimation = this._animation;
+    this._animation && this._animation.stop();
+    this._animation = animation;
+    animation.start(this._value, value => {
+      // Natively driven animations will never call into that callback
+      this._updateValue(value, true /* flush */);
+    }, result => {
+      this._animation = null;
+      if (handle !== null) {
+        _InteractionManager.default.clearInteractionHandle(handle);
+      }
+      callback && callback(result);
+    }, previousAnimation, this);
+  }
+
+  /**
+   * Typically only used internally.
+   */
+  stopTracking() {
+    this._tracking && this._tracking.__detach();
+    this._tracking = null;
+  }
+
+  /**
+   * Typically only used internally.
+   */
+  track(tracking) {
+    this.stopTracking();
+    this._tracking = tracking;
+    // Make sure that the tracking animation starts executing
+    this._tracking && this._tracking.update();
+  }
+  _updateValue(value, flush) {
+    if (value === undefined) {
+      throw new Error('AnimatedValue: Attempting to set value to undefined');
+    }
+    this._value = value;
+    if (flush) {
+      _flush(this);
+    }
+    super.__callListeners(this.__getValue());
+  }
+  __getNativeConfig() {
+    return {
+      type: 'value',
+      value: this._value,
+      offset: this._offset
+    };
+  }
+}
+var _default = exports.default = AnimatedValue;
+module.exports = exports.default;