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

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

@@ -0,0 +1,140 @@
+/**
+ * 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 _AnimatedEvent = require("./AnimatedEvent");
+var _AnimatedImplementation = _interopRequireDefault(require("./AnimatedImplementation"));
+var _AnimatedInterpolation = _interopRequireDefault(require("./nodes/AnimatedInterpolation"));
+var _AnimatedNode = _interopRequireDefault(require("./nodes/AnimatedNode"));
+var _AnimatedValue = _interopRequireDefault(require("./nodes/AnimatedValue"));
+var _AnimatedValueXY = _interopRequireDefault(require("./nodes/AnimatedValueXY"));
+var _createAnimatedComponent = _interopRequireDefault(require("./createAnimatedComponent"));
+var _AnimatedColor = _interopRequireDefault(require("./nodes/AnimatedColor"));
+/**
+ * Animations are a source of flakiness in snapshot testing. This mock replaces
+ * animation functions from AnimatedImplementation with empty animations for
+ * predictability in tests. When possible the animation will run immediately
+ * to the final state.
+ */
+
+// Prevent any callback invocation from recursively triggering another
+// callback, which may trigger another animation
+var inAnimationCallback = false;
+function mockAnimationStart(start) {
+  return callback => {
+    var guardedCallback = callback == null ? callback : function () {
+      if (inAnimationCallback) {
+        console.warn('Ignoring recursive animation callback when running mock animations');
+        return;
+      }
+      inAnimationCallback = true;
+      try {
+        callback(...arguments);
+      } finally {
+        inAnimationCallback = false;
+      }
+    };
+    start(guardedCallback);
+  };
+}
+var emptyAnimation = {
+  start: () => {},
+  stop: () => {},
+  reset: () => {},
+  _startNativeLoop: () => {},
+  _isUsingNativeDriver: () => {
+    return false;
+  }
+};
+var mockCompositeAnimation = animations => (0, _objectSpread2.default)((0, _objectSpread2.default)({}, emptyAnimation), {}, {
+  start: mockAnimationStart(callback => {
+    animations.forEach(animation => animation.start());
+    callback == null || callback({
+      finished: true
+    });
+  })
+});
+var spring = function spring(value, config) {
+  var anyValue = value;
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, emptyAnimation), {}, {
+    start: mockAnimationStart(callback => {
+      anyValue.setValue(config.toValue);
+      callback == null || callback({
+        finished: true
+      });
+    })
+  });
+};
+var timing = function timing(value, config) {
+  var anyValue = value;
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, emptyAnimation), {}, {
+    start: mockAnimationStart(callback => {
+      anyValue.setValue(config.toValue);
+      callback == null || callback({
+        finished: true
+      });
+    })
+  });
+};
+var decay = function decay(value, config) {
+  return emptyAnimation;
+};
+var sequence = function sequence(animations) {
+  return mockCompositeAnimation(animations);
+};
+var parallel = function parallel(animations, config) {
+  return mockCompositeAnimation(animations);
+};
+var delay = function delay(time) {
+  return emptyAnimation;
+};
+var stagger = function stagger(time, animations) {
+  return mockCompositeAnimation(animations);
+};
+var loop = function loop(animation, // $FlowFixMe[prop-missing]
+_temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+    _ref$iterations = _ref.iterations,
+    iterations = _ref$iterations === void 0 ? -1 : _ref$iterations;
+  return emptyAnimation;
+};
+var _default = exports.default = {
+  Value: _AnimatedValue.default,
+  ValueXY: _AnimatedValueXY.default,
+  Color: _AnimatedColor.default,
+  Interpolation: _AnimatedInterpolation.default,
+  Node: _AnimatedNode.default,
+  decay,
+  timing,
+  spring,
+  add: _AnimatedImplementation.default.add,
+  subtract: _AnimatedImplementation.default.subtract,
+  divide: _AnimatedImplementation.default.divide,
+  multiply: _AnimatedImplementation.default.multiply,
+  modulo: _AnimatedImplementation.default.modulo,
+  diffClamp: _AnimatedImplementation.default.diffClamp,
+  delay,
+  sequence,
+  parallel,
+  stagger,
+  loop,
+  event: _AnimatedImplementation.default.event,
+  createAnimatedComponent: _createAnimatedComponent.default,
+  attachNativeEvent: _AnimatedEvent.attachNativeEvent,
+  forkEvent: _AnimatedImplementation.default.forkEvent,
+  unforkEvent: _AnimatedImplementation.default.unforkEvent,
+  Event: _AnimatedEvent.AnimatedEvent
+};
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Animated/AnimatedPlatformConfig.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/Animated/Easing.js

@@ -0,0 +1,253 @@
+/**
+ * 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 _bezier2 = _interopRequireDefault(require("./bezier"));
+var ease;
+
+/**
+ * The `Easing` module implements common easing functions. This module is used
+ * by [Animate.timing()](docs/animate.html#timing) to convey physically
+ * believable motion in animations.
+ *
+ * You can find a visualization of some common easing functions at
+ * http://easings.net/
+ *
+ * ### Predefined animations
+ *
+ * The `Easing` module provides several predefined animations through the
+ * following methods:
+ *
+ * - [`back`](docs/easing.html#back) provides a simple animation where the
+ *   object goes slightly back before moving forward
+ * - [`bounce`](docs/easing.html#bounce) provides a bouncing animation
+ * - [`ease`](docs/easing.html#ease) provides a simple inertial animation
+ * - [`elastic`](docs/easing.html#elastic) provides a simple spring interaction
+ *
+ * ### Standard functions
+ *
+ * Three standard easing functions are provided:
+ *
+ * - [`linear`](docs/easing.html#linear)
+ * - [`quad`](docs/easing.html#quad)
+ * - [`cubic`](docs/easing.html#cubic)
+ *
+ * The [`poly`](docs/easing.html#poly) function can be used to implement
+ * quartic, quintic, and other higher power functions.
+ *
+ * ### Additional functions
+ *
+ * Additional mathematical functions are provided by the following methods:
+ *
+ * - [`bezier`](docs/easing.html#bezier) provides a cubic bezier curve
+ * - [`circle`](docs/easing.html#circle) provides a circular function
+ * - [`sin`](docs/easing.html#sin) provides a sinusoidal function
+ * - [`exp`](docs/easing.html#exp) provides an exponential function
+ *
+ * The following helpers are used to modify other easing functions.
+ *
+ * - [`in`](docs/easing.html#in) runs an easing function forwards
+ * - [`inOut`](docs/easing.html#inout) makes any easing function symmetrical
+ * - [`out`](docs/easing.html#out) runs an easing function backwards
+ */
+class Easing {
+  /**
+   * A stepping function, returns 1 for any positive value of `n`.
+   */
+  static step0(n) {
+    return n > 0 ? 1 : 0;
+  }
+
+  /**
+   * A stepping function, returns 1 if `n` is greater than or equal to 1.
+   */
+  static step1(n) {
+    return n >= 1 ? 1 : 0;
+  }
+
+  /**
+   * A linear function, `f(t) = t`. Position correlates to elapsed time one to
+   * one.
+   *
+   * http://cubic-bezier.com/#0,0,1,1
+   */
+  static linear(t) {
+    return t;
+  }
+
+  /**
+   * A simple inertial interaction, similar to an object slowly accelerating to
+   * speed.
+   *
+   * http://cubic-bezier.com/#.42,0,1,1
+   */
+  static ease(t) {
+    if (!ease) {
+      ease = Easing.bezier(0.42, 0, 1, 1);
+    }
+    return ease(t);
+  }
+
+  /**
+   * A quadratic function, `f(t) = t * t`. Position equals the square of elapsed
+   * time.
+   *
+   * http://easings.net/#easeInQuad
+   */
+  static quad(t) {
+    return t * t;
+  }
+
+  /**
+   * A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed
+   * time.
+   *
+   * http://easings.net/#easeInCubic
+   */
+  static cubic(t) {
+    return t * t * t;
+  }
+
+  /**
+   * A power function. Position is equal to the Nth power of elapsed time.
+   *
+   * n = 4: http://easings.net/#easeInQuart
+   * n = 5: http://easings.net/#easeInQuint
+   */
+  static poly(n) {
+    return t => Math.pow(t, n);
+  }
+
+  /**
+   * A sinusoidal function.
+   *
+   * http://easings.net/#easeInSine
+   */
+  static sin(t) {
+    return 1 - Math.cos(t * Math.PI / 2);
+  }
+
+  /**
+   * A circular function.
+   *
+   * http://easings.net/#easeInCirc
+   */
+  static circle(t) {
+    return 1 - Math.sqrt(1 - t * t);
+  }
+
+  /**
+   * An exponential function.
+   *
+   * http://easings.net/#easeInExpo
+   */
+  static exp(t) {
+    return Math.pow(2, 10 * (t - 1));
+  }
+
+  /**
+   * A simple elastic interaction, similar to a spring oscillating back and
+   * forth.
+   *
+   * Default bounciness is 1, which overshoots a little bit once. 0 bounciness
+   * doesn't overshoot at all, and bounciness of N > 1 will overshoot about N
+   * times.
+   *
+   * http://easings.net/#easeInElastic
+   */
+  static elastic(bounciness) {
+    if (bounciness === void 0) {
+      bounciness = 1;
+    }
+    var p = bounciness * Math.PI;
+    return t => 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
+  }
+
+  /**
+   * Use with `Animated.parallel()` to create a simple effect where the object
+   * animates back slightly as the animation starts.
+   *
+   * Wolfram Plot:
+   *
+   * - http://tiny.cc/back_default (s = 1.70158, default)
+   */
+  static back(s) {
+    if (s === void 0) {
+      s = 1.70158;
+    }
+    return t => t * t * ((s + 1) * t - s);
+  }
+
+  /**
+   * Provides a simple bouncing effect.
+   *
+   * http://easings.net/#easeInBounce
+   */
+  static bounce(t) {
+    if (t < 1 / 2.75) {
+      return 7.5625 * t * t;
+    }
+    if (t < 2 / 2.75) {
+      var _t = t - 1.5 / 2.75;
+      return 7.5625 * _t * _t + 0.75;
+    }
+    if (t < 2.5 / 2.75) {
+      var _t2 = t - 2.25 / 2.75;
+      return 7.5625 * _t2 * _t2 + 0.9375;
+    }
+    var t2 = t - 2.625 / 2.75;
+    return 7.5625 * t2 * t2 + 0.984375;
+  }
+
+  /**
+   * Provides a cubic bezier curve, equivalent to CSS Transitions'
+   * `transition-timing-function`.
+   *
+   * A useful tool to visualize cubic bezier curves can be found at
+   * http://cubic-bezier.com/
+   */
+  static bezier(x1, y1, x2, y2) {
+    return (0, _bezier2.default)(x1, y1, x2, y2);
+  }
+
+  /**
+   * Runs an easing function forwards.
+   */
+  static in(easing) {
+    return easing;
+  }
+
+  /**
+   * Runs an easing function backwards.
+   */
+  static out(easing) {
+    return t => 1 - easing(1 - t);
+  }
+
+  /**
+   * Makes any easing function symmetrical. The easing function will run
+   * forwards for half of the duration, then backwards for the rest of the
+   * duration.
+   */
+  static inOut(easing) {
+    return t => {
+      if (t < 0.5) {
+        return easing(t * 2) / 2;
+      }
+      return 1 - easing((1 - t) * 2) / 2;
+    };
+  }
+}
+var _default = exports.default = Easing;
+module.exports = exports.default;