@tamagui/react-native-web-lite 1.129.13 → 1.129.15

package/src/vendor/react-native/Animated/AnimatedMock.js

@@ -4,47 +4,48 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *
+ * @format
  * @format
  */
+
 'use strict'
 
 import { AnimatedEvent, attachNativeEvent } from './AnimatedEvent'
 import AnimatedImplementation from './AnimatedImplementation'
-import createAnimatedComponent from './createAnimatedComponent'
-import AnimatedColor from './nodes/AnimatedColor'
 import AnimatedInterpolation from './nodes/AnimatedInterpolation'
 import AnimatedNode from './nodes/AnimatedNode'
 import AnimatedValue from './nodes/AnimatedValue'
 import AnimatedValueXY from './nodes/AnimatedValueXY'
+
+import createAnimatedComponent from './createAnimatedComponent'
+
+import AnimatedColor from './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
-
+let inAnimationCallback = false
 function mockAnimationStart(start) {
   return (callback) => {
-    var guardedCallback =
+    const guardedCallback =
       callback == null
         ? callback
-        : function () {
+        : (...args) => {
             if (inAnimationCallback) {
               console.warn(
                 'Ignoring recursive animation callback when running mock animations'
               )
               return
             }
-
             inAnimationCallback = true
-
             try {
-              callback(...arguments)
+              callback(...args)
             } finally {
               inAnimationCallback = false
             }
@@ -53,7 +54,9 @@ function mockAnimationStart(start) {
   }
 }
 
-var emptyAnimation = {
+// CompositeAnimation interface removed
+
+const emptyAnimation = {
   start: () => {},
   stop: () => {},
   reset: () => {},
@@ -63,76 +66,59 @@ var emptyAnimation = {
   },
 }
 
-var mockCompositeAnimation = (animations) => ({
+const mockCompositeAnimation = (animations) => ({
   ...emptyAnimation,
   start: mockAnimationStart((callback) => {
     animations.forEach((animation) => animation.start())
-    callback == null
-      ? void 0
-      : callback({
-          finished: true,
-        })
+    callback?.({ finished: true })
   }),
 })
 
-var spring = function spring(value, config) {
-  var anyValue = value
+const spring = function (value, config) {
+  const anyValue = value
   return {
     ...emptyAnimation,
     start: mockAnimationStart((callback) => {
       anyValue.setValue(config.toValue)
-      callback == null
-        ? void 0
-        : callback({
-            finished: true,
-          })
+      callback?.({ finished: true })
     }),
   }
 }
 
-var timing = function timing(value, config) {
-  var anyValue = value
+const timing = function (value, config) {
+  const anyValue = value
   return {
     ...emptyAnimation,
     start: mockAnimationStart((callback) => {
       anyValue.setValue(config.toValue)
-      callback == null
-        ? void 0
-        : callback({
-            finished: true,
-          })
+      callback?.({ finished: true })
     }),
   }
 }
 
-var decay = function decay(value, config) {
+const decay = function (value, config) {
   return emptyAnimation
 }
 
-var sequence = function sequence(animations) {
+const sequence = function (animations) {
   return mockCompositeAnimation(animations)
 }
 
-var parallel = function parallel(animations, config) {
+const parallel = function (animations, config) {
   return mockCompositeAnimation(animations)
 }
 
-var delay = function delay(time) {
+const delay = function (time) {
   return emptyAnimation
 }
 
-var stagger = function stagger(time, animations) {
+const stagger = function (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
+// LoopAnimationConfig interface removed
 
+const loop = function (animation, { iterations = -1 } = {}) {
   return emptyAnimation
 }
 

package/src/vendor/react-native/Animated/AnimatedPlatformConfig.js

@@ -4,7 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * 
+ * @format
  * @format
  */
-'use strict';
+
+'use strict';
+

package/src/vendor/react-native/Animated/Easing.js

@@ -5,12 +5,15 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @format
- *
+ * @format
  */
-'use strict'
 
-import _bezier from './bezier'
-var ease
+'use strict';
+
+import _bezier from './bezier';
+
+let ease;
+
 /**
  * The `Easing` module implements common easing functions. This module is used
  * by [Animate.timing()](docs/animate.html#timing) to convey physically
@@ -56,102 +59,101 @@ var ease
  * - [`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
+    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
+    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
+    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)
+      ease = Easing.bezier(0.42, 0, 1, 1);
     }
-
-    return ease(t)
+    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
+    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
+    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)
+    return (t) => Math.pow(t, n);
   }
+
   /**
    * A sinusoidal function.
    *
    * http://easings.net/#easeInSine
    */
-
   static sin(t) {
-    return 1 - Math.cos((t * Math.PI) / 2)
+    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)
+    return 1 - Math.sqrt(1 - t * t);
   }
+
   /**
    * An exponential function.
    *
    * http://easings.net/#easeInExpo
    */
-
   static exp(t) {
-    return Math.pow(2, 10 * (t - 1))
+    return Math.pow(2, 10 * (t - 1));
   }
+
   /**
    * A simple elastic interaction, similar to a spring oscillating back and
    * forth.
@@ -162,15 +164,11 @@ class Easing {
    *
    * 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)
+  static elastic(bounciness = 1) {
+    const 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.
@@ -179,40 +177,34 @@ class Easing {
    *
    * - 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)
+  static back(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
+      return 7.5625 * t * t;
     }
 
     if (t < 2 / 2.75) {
-      var _t = t - 1.5 / 2.75
-
-      return 7.5625 * _t * _t + 0.75
+      const t2 = t - 1.5 / 2.75;
+      return 7.5625 * t2 * t2 + 0.75;
     }
 
     if (t < 2.5 / 2.75) {
-      var _t2 = t - 2.25 / 2.75
-
-      return 7.5625 * _t2 * _t2 + 0.9375
+      const 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
+    const 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`.
@@ -220,39 +212,42 @@ class Easing {
    * A useful tool to visualize cubic bezier curves can be found at
    * http://cubic-bezier.com/
    */
-
-  static bezier(x1, y1, x2, y2) {
-    return _bezier(x1, y1, x2, y2)
+  static bezier(
+    x1,
+    y1,
+    x2,
+    y2,
+  ) {
+    return _bezier(x1, y1, x2, y2);
   }
+
   /**
    * Runs an easing function forwards.
    */
-
   static in(easing) {
-    return easing
+    return easing;
   }
+
   /**
    * Runs an easing function backwards.
    */
-
   static out(easing) {
-    return (t) => 1 - easing(1 - t)
+    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) => {
+    return t => {
       if (t < 0.5) {
-        return easing(t * 2) / 2
+        return easing(t * 2) / 2;
       }
-
-      return 1 - easing((1 - t) * 2) / 2
-    }
+      return 1 - easing((1 - t) * 2) / 2;
+    };
   }
 }
 
-export default Easing
+export default Easing;