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

package/dist/esm/vendor/react-native/Animated/AnimatedImplementation.mjs

@@ -1,21 +1,23 @@
 import { AnimatedEvent, attachNativeEvent } from "./AnimatedEvent.mjs";
-import DecayAnimation from "./animations/DecayAnimation.mjs";
-import SpringAnimation from "./animations/SpringAnimation.mjs";
-import TimingAnimation from "./animations/TimingAnimation.mjs";
-import createAnimatedComponent from "./createAnimatedComponent.mjs";
 import AnimatedAddition from "./nodes/AnimatedAddition.mjs";
-import AnimatedColor from "./nodes/AnimatedColor.mjs";
 import AnimatedDiffClamp from "./nodes/AnimatedDiffClamp.mjs";
 import AnimatedDivision from "./nodes/AnimatedDivision.mjs";
 import AnimatedInterpolation from "./nodes/AnimatedInterpolation.mjs";
 import AnimatedModulo from "./nodes/AnimatedModulo.mjs";
 import AnimatedMultiplication from "./nodes/AnimatedMultiplication.mjs";
 import AnimatedNode from "./nodes/AnimatedNode.mjs";
+import "./nodes/AnimatedProps.mjs";
 import AnimatedSubtraction from "./nodes/AnimatedSubtraction.mjs";
 import AnimatedTracking from "./nodes/AnimatedTracking.mjs";
 import AnimatedValue from "./nodes/AnimatedValue.mjs";
 import AnimatedValueXY from "./nodes/AnimatedValueXY.mjs";
-var add = function (a, b) {
+import DecayAnimation from "./animations/DecayAnimation.mjs";
+import SpringAnimation from "./animations/SpringAnimation.mjs";
+import TimingAnimation from "./animations/TimingAnimation.mjs";
+import createAnimatedComponent from "./createAnimatedComponent.mjs";
+import "./animations/Animation.mjs";
+import AnimatedColor from "./nodes/AnimatedColor.mjs";
+const add = function (a, b) {
     return new AnimatedAddition(a, b);
   },
   subtract = function (a, b) {
@@ -34,31 +36,32 @@ var add = function (a, b) {
     return new AnimatedDiffClamp(a, min, max);
   },
   _combineCallbacks = function (callback, config) {
-    return callback && config.onComplete ? function () {
-      config.onComplete && config.onComplete(...arguments), callback && callback(...arguments);
+    return callback && config.onComplete ? (...args) => {
+      config.onComplete && config.onComplete(...args), callback && callback(...args);
     } : callback || config.onComplete;
   },
   maybeVectorAnim = function (value, config, anim) {
     if (value instanceof AnimatedValueXY) {
-      var configX = {
+      const configX = {
           ...config
         },
         configY = {
           ...config
         };
-      for (var key in config) {
-        var _config$key = config[key],
-          x = _config$key.x,
-          y = _config$key.y;
+      for (const key in config) {
+        const {
+          x,
+          y
+        } = config[key];
         x !== void 0 && y !== void 0 && (configX[key] = x, configY[key] = y);
       }
-      var aX = anim(value.x, configX),
+      const aX = anim(value.x, configX),
         aY = anim(value.y, configY);
       return parallel([aX, aY], {
         stopTogether: !1
       });
     } else if (value instanceof AnimatedColor) {
-      var configR = {
+      const configR = {
           ...config
         },
         configG = {
@@ -70,15 +73,16 @@ var add = function (a, b) {
         configA = {
           ...config
         };
-      for (var _key in config) {
-        var _config$_key = config[_key],
-          r = _config$_key.r,
-          g = _config$_key.g,
-          b = _config$_key.b,
-          a = _config$_key.a;
-        r !== void 0 && g !== void 0 && b !== void 0 && a !== void 0 && (configR[_key] = r, configG[_key] = g, configB[_key] = b, configA[_key] = a);
+      for (const key in config) {
+        const {
+          r,
+          g,
+          b,
+          a
+        } = config[key];
+        r !== void 0 && g !== void 0 && b !== void 0 && a !== void 0 && (configR[key] = r, configG[key] = g, configB[key] = b, configA[key] = a);
       }
-      var aR = anim(value.r, configR),
+      const aR = anim(value.r, configR),
         aG = anim(value.g, configG),
         aB = anim(value.b, configB),
         aA = anim(value.a, configA);
@@ -88,16 +92,16 @@ var add = function (a, b) {
     }
     return null;
   },
-  spring = function spring2(value, config) {
-    var _start = function (animatedValue, configuration, callback) {
+  spring = function (value, config) {
+    const start = function (animatedValue, configuration, callback) {
       callback = _combineCallbacks(callback, configuration);
-      var singleValue = animatedValue,
+      const singleValue = animatedValue,
         singleConfig = configuration;
       singleValue.stopTracking(), configuration.toValue instanceof AnimatedNode ? singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, SpringAnimation, singleConfig, callback)) : singleValue.animate(new SpringAnimation(singleConfig), callback);
     };
-    return maybeVectorAnim(value, config, spring2) || {
+    return maybeVectorAnim(value, config, spring) || {
       start: function (callback) {
-        _start(value, config, callback);
+        start(value, config, callback);
       },
       stop: function () {
         value.stopAnimation();
@@ -106,27 +110,27 @@ var add = function (a, b) {
         value.resetAnimation();
       },
       _startNativeLoop: function (iterations) {
-        var singleConfig = {
+        const singleConfig = {
           ...config,
           iterations
         };
-        _start(value, singleConfig);
+        start(value, singleConfig);
       },
       _isUsingNativeDriver: function () {
         return config.useNativeDriver || !1;
       }
     };
   },
-  timing = function timing2(value, config) {
-    var _start2 = function (animatedValue, configuration, callback) {
+  timing = function (value, config) {
+    const start = function (animatedValue, configuration, callback) {
       callback = _combineCallbacks(callback, configuration);
-      var singleValue = animatedValue,
+      const singleValue = animatedValue,
         singleConfig = configuration;
       singleValue.stopTracking(), configuration.toValue instanceof AnimatedNode ? singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, TimingAnimation, singleConfig, callback)) : singleValue.animate(new TimingAnimation(singleConfig), callback);
     };
-    return maybeVectorAnim(value, config, timing2) || {
+    return maybeVectorAnim(value, config, timing) || {
       start: function (callback) {
-        _start2(value, config, callback);
+        start(value, config, callback);
       },
       stop: function () {
         value.stopAnimation();
@@ -135,27 +139,27 @@ var add = function (a, b) {
         value.resetAnimation();
       },
       _startNativeLoop: function (iterations) {
-        var singleConfig = {
+        const singleConfig = {
           ...config,
           iterations
         };
-        _start2(value, singleConfig);
+        start(value, singleConfig);
       },
       _isUsingNativeDriver: function () {
         return config.useNativeDriver || !1;
       }
     };
   },
-  decay = function decay2(value, config) {
-    var _start3 = function (animatedValue, configuration, callback) {
+  decay = function (value, config) {
+    const start = function (animatedValue, configuration, callback) {
       callback = _combineCallbacks(callback, configuration);
-      var singleValue = animatedValue,
+      const singleValue = animatedValue,
         singleConfig = configuration;
       singleValue.stopTracking(), singleValue.animate(new DecayAnimation(singleConfig), callback);
     };
-    return maybeVectorAnim(value, config, decay2) || {
+    return maybeVectorAnim(value, config, decay) || {
       start: function (callback) {
-        _start3(value, config, callback);
+        start(value, config, callback);
       },
       stop: function () {
         value.stopAnimation();
@@ -164,11 +168,11 @@ var add = function (a, b) {
         value.resetAnimation();
       },
       _startNativeLoop: function (iterations) {
-        var singleConfig = {
+        const singleConfig = {
           ...config,
           iterations
         };
-        _start3(value, singleConfig);
+        start(value, singleConfig);
       },
       _isUsingNativeDriver: function () {
         return config.useNativeDriver || !1;
@@ -176,10 +180,10 @@ var add = function (a, b) {
     };
   },
   sequence = function (animations) {
-    var current = 0;
+    let current = 0;
     return {
       start: function (callback) {
-        var onComplete = function onComplete2(result) {
+        const onComplete = function (result) {
           if (!result.finished) {
             callback && callback(result);
             return;
@@ -188,7 +192,7 @@ var add = function (a, b) {
             callback && callback(result);
             return;
           }
-          animations[current].start(onComplete2);
+          animations[current].start(onComplete);
         };
         animations.length === 0 ? callback && callback({
           finished: !0
@@ -211,8 +215,8 @@ var add = function (a, b) {
     };
   },
   parallel = function (animations, config) {
-    var doneCount = 0,
-      hasEnded = {},
+    let doneCount = 0;
+    const hasEnded = {},
       stopTogether = !(config && config.stopTogether === !1),
       result = {
         start: function (callback) {
@@ -223,7 +227,7 @@ var add = function (a, b) {
             return;
           }
           animations.forEach((animation, idx) => {
-            var cb = function (endResult) {
+            const cb = function (endResult) {
               if (hasEnded[idx] = !0, doneCount++, doneCount === animations.length) {
                 doneCount = 0, callback && callback(endResult);
                 return;
@@ -265,20 +269,18 @@ var add = function (a, b) {
   stagger = function (time, animations) {
     return parallel(animations.map((animation, i) => sequence([delay(time * i), animation])));
   },
-  loop = function (animation, _temp) {
-    var _ref = _temp === void 0 ? {} : _temp,
-      _ref$iterations = _ref.iterations,
-      iterations = _ref$iterations === void 0 ? -1 : _ref$iterations,
-      _ref$resetBeforeItera = _ref.resetBeforeIteration,
-      resetBeforeIteration = _ref$resetBeforeItera === void 0 ? !0 : _ref$resetBeforeItera,
-      isFinished = !1,
+  loop = function (animation, {
+    iterations = -1,
+    resetBeforeIteration = !0
+  } = {}) {
+    let isFinished = !1,
       iterationsSoFar = 0;
     return {
       start: function (callback) {
-        var restart = function restart2(result) {
-          result === void 0 && (result = {
-            finished: !0
-          }), isFinished || iterationsSoFar === iterations || result.finished === !1 ? callback && callback(result) : (iterationsSoFar++, resetBeforeIteration && animation.reset(), animation.start(restart2));
+        const restart = function (result = {
+          finished: !0
+        }) {
+          isFinished || iterationsSoFar === iterations || result.finished === !1 ? callback && callback(result) : (iterationsSoFar++, resetBeforeIteration && animation.reset(), animation.start(restart));
         };
         !animation || iterations === 0 ? callback && callback({
           finished: !0
@@ -298,181 +300,181 @@ var add = function (a, b) {
       }
     };
   };
-function forkEvent(event3, listener) {
-  return event3 ? event3 instanceof AnimatedEvent ? (event3.__addListener(listener), event3) : function () {
-    typeof event3 == "function" && event3(...arguments), listener(...arguments);
+function forkEvent(event2, listener) {
+  return event2 ? event2 instanceof AnimatedEvent ? (event2.__addListener(listener), event2) : (...args) => {
+    typeof event2 == "function" && event2(...args), listener(...args);
   } : listener;
 }
-function unforkEvent(event3, listener) {
-  event3 && event3 instanceof AnimatedEvent && event3.__removeListener(listener);
+function unforkEvent(event2, listener) {
+  event2 && event2 instanceof AnimatedEvent && event2.__removeListener(listener);
 }
-var event = function (argMapping, config) {
-    var animatedEvent = new AnimatedEvent(argMapping, config);
-    return animatedEvent.__isNative ? animatedEvent : animatedEvent.__getHandler();
-  },
-  AnimatedImplementation_default = {
-    /**
-     * Standard value class for driving animations.  Typically initialized with
-     * `new Animated.Value(0);`
-     *
-     * See https://reactnative.dev/docs/animated#value
-     */
-    Value: AnimatedValue,
-    /**
-     * 2D value class for driving 2D animations, such as pan gestures.
-     *
-     * See https://reactnative.dev/docs/animatedvaluexy
-     */
-    ValueXY: AnimatedValueXY,
-    /**
-     * Value class for driving color animations.
-     */
-    Color: AnimatedColor,
-    /**
-     * Exported to use the Interpolation type in flow.
-     *
-     * See https://reactnative.dev/docs/animated#interpolation
-     */
-    Interpolation: AnimatedInterpolation,
-    /**
-     * Exported for ease of type checking. All animated values derive from this
-     * class.
-     *
-     * See https://reactnative.dev/docs/animated#node
-     */
-    Node: AnimatedNode,
-    /**
-     * Animates a value from an initial velocity to zero based on a decay
-     * coefficient.
-     *
-     * See https://reactnative.dev/docs/animated#decay
-     */
-    decay,
-    /**
-     * Animates a value along a timed easing curve. The Easing module has tons of
-     * predefined curves, or you can use your own function.
-     *
-     * See https://reactnative.dev/docs/animated#timing
-     */
-    timing,
-    /**
-     * Animates a value according to an analytical spring model based on
-     * damped harmonic oscillation.
-     *
-     * See https://reactnative.dev/docs/animated#spring
-     */
-    spring,
-    /**
-     * Creates a new Animated value composed from two Animated values added
-     * together.
-     *
-     * See https://reactnative.dev/docs/animated#add
-     */
-    add,
-    /**
-     * Creates a new Animated value composed by subtracting the second Animated
-     * value from the first Animated value.
-     *
-     * See https://reactnative.dev/docs/animated#subtract
-     */
-    subtract,
-    /**
-     * Creates a new Animated value composed by dividing the first Animated value
-     * by the second Animated value.
-     *
-     * See https://reactnative.dev/docs/animated#divide
-     */
-    divide,
-    /**
-     * Creates a new Animated value composed from two Animated values multiplied
-     * together.
-     *
-     * See https://reactnative.dev/docs/animated#multiply
-     */
-    multiply,
-    /**
-     * Creates a new Animated value that is the (non-negative) modulo of the
-     * provided Animated value.
-     *
-     * See https://reactnative.dev/docs/animated#modulo
-     */
-    modulo,
-    /**
-     * Create a new Animated value that is limited between 2 values. It uses the
-     * difference between the last value so even if the value is far from the
-     * bounds it will start changing when the value starts getting closer again.
-     *
-     * See https://reactnative.dev/docs/animated#diffclamp
-     */
-    diffClamp,
-    /**
-     * Starts an animation after the given delay.
-     *
-     * See https://reactnative.dev/docs/animated#delay
-     */
-    delay,
-    /**
-     * Starts an array of animations in order, waiting for each to complete
-     * before starting the next. If the current running animation is stopped, no
-     * following animations will be started.
-     *
-     * See https://reactnative.dev/docs/animated#sequence
-     */
-    sequence,
-    /**
-     * Starts an array of animations all at the same time. By default, if one
-     * of the animations is stopped, they will all be stopped. You can override
-     * this with the `stopTogether` flag.
-     *
-     * See https://reactnative.dev/docs/animated#parallel
-     */
-    parallel,
-    /**
-     * Array of animations may run in parallel (overlap), but are started in
-     * sequence with successive delays.  Nice for doing trailing effects.
-     *
-     * See https://reactnative.dev/docs/animated#stagger
-     */
-    stagger,
-    /**
-     * Loops a given animation continuously, so that each time it reaches the
-     * end, it resets and begins again from the start.
-     *
-     * See https://reactnative.dev/docs/animated#loop
-     */
-    loop,
-    /**
-     * Takes an array of mappings and extracts values from each arg accordingly,
-     * then calls `setValue` on the mapped outputs.
-     *
-     * See https://reactnative.dev/docs/animated#event
-     */
-    event,
-    /**
-     * Make any React component Animatable.  Used to create `Animated.View`, etc.
-     *
-     * See https://reactnative.dev/docs/animated#createanimatedcomponent
-     */
-    createAnimatedComponent,
-    /**
-     * Imperative API to attach an animated value to an event on a view. Prefer
-     * using `Animated.event` with `useNativeDrive: true` if possible.
-     *
-     * See https://reactnative.dev/docs/animated#attachnativeevent
-     */
-    attachNativeEvent,
-    /**
-     * Advanced imperative API for snooping on animated events that are passed in
-     * through props. Use values directly where possible.
-     *
-     * See https://reactnative.dev/docs/animated#forkevent
-     */
-    forkEvent,
-    unforkEvent,
-    /**
-     * Expose Event class, so it can be used as a type for type checkers.
-     */
-    Event: AnimatedEvent
-  };
+const event = function (argMapping, config) {
+  const animatedEvent = new AnimatedEvent(argMapping, config);
+  return animatedEvent.__isNative ? animatedEvent : animatedEvent.__getHandler();
+};
+var AnimatedImplementation_default = {
+  /**
+   * Standard value class for driving animations.  Typically initialized with
+   * `new Animated.Value(0);`
+   *
+   * See https://reactnative.dev/docs/animated#value
+   */
+  Value: AnimatedValue,
+  /**
+   * 2D value class for driving 2D animations, such as pan gestures.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy
+   */
+  ValueXY: AnimatedValueXY,
+  /**
+   * Value class for driving color animations.
+   */
+  Color: AnimatedColor,
+  /**
+   * Exported to use the Interpolation type in flow.
+   *
+   * See https://reactnative.dev/docs/animated#interpolation
+   */
+  Interpolation: AnimatedInterpolation,
+  /**
+   * Exported for ease of type checking. All animated values derive from this
+   * class.
+   *
+   * See https://reactnative.dev/docs/animated#node
+   */
+  Node: AnimatedNode,
+  /**
+   * Animates a value from an initial velocity to zero based on a decay
+   * coefficient.
+   *
+   * See https://reactnative.dev/docs/animated#decay
+   */
+  decay,
+  /**
+   * Animates a value along a timed easing curve. The Easing module has tons of
+   * predefined curves, or you can use your own function.
+   *
+   * See https://reactnative.dev/docs/animated#timing
+   */
+  timing,
+  /**
+   * Animates a value according to an analytical spring model based on
+   * damped harmonic oscillation.
+   *
+   * See https://reactnative.dev/docs/animated#spring
+   */
+  spring,
+  /**
+   * Creates a new Animated value composed from two Animated values added
+   * together.
+   *
+   * See https://reactnative.dev/docs/animated#add
+   */
+  add,
+  /**
+   * Creates a new Animated value composed by subtracting the second Animated
+   * value from the first Animated value.
+   *
+   * See https://reactnative.dev/docs/animated#subtract
+   */
+  subtract,
+  /**
+   * Creates a new Animated value composed by dividing the first Animated value
+   * by the second Animated value.
+   *
+   * See https://reactnative.dev/docs/animated#divide
+   */
+  divide,
+  /**
+   * Creates a new Animated value composed from two Animated values multiplied
+   * together.
+   *
+   * See https://reactnative.dev/docs/animated#multiply
+   */
+  multiply,
+  /**
+   * Creates a new Animated value that is the (non-negative) modulo of the
+   * provided Animated value.
+   *
+   * See https://reactnative.dev/docs/animated#modulo
+   */
+  modulo,
+  /**
+   * Create a new Animated value that is limited between 2 values. It uses the
+   * difference between the last value so even if the value is far from the
+   * bounds it will start changing when the value starts getting closer again.
+   *
+   * See https://reactnative.dev/docs/animated#diffclamp
+   */
+  diffClamp,
+  /**
+   * Starts an animation after the given delay.
+   *
+   * See https://reactnative.dev/docs/animated#delay
+   */
+  delay,
+  /**
+   * Starts an array of animations in order, waiting for each to complete
+   * before starting the next. If the current running animation is stopped, no
+   * following animations will be started.
+   *
+   * See https://reactnative.dev/docs/animated#sequence
+   */
+  sequence,
+  /**
+   * Starts an array of animations all at the same time. By default, if one
+   * of the animations is stopped, they will all be stopped. You can override
+   * this with the `stopTogether` flag.
+   *
+   * See https://reactnative.dev/docs/animated#parallel
+   */
+  parallel,
+  /**
+   * Array of animations may run in parallel (overlap), but are started in
+   * sequence with successive delays.  Nice for doing trailing effects.
+   *
+   * See https://reactnative.dev/docs/animated#stagger
+   */
+  stagger,
+  /**
+   * Loops a given animation continuously, so that each time it reaches the
+   * end, it resets and begins again from the start.
+   *
+   * See https://reactnative.dev/docs/animated#loop
+   */
+  loop,
+  /**
+   * Takes an array of mappings and extracts values from each arg accordingly,
+   * then calls `setValue` on the mapped outputs.
+   *
+   * See https://reactnative.dev/docs/animated#event
+   */
+  event,
+  /**
+   * Make any React component Animatable.  Used to create `Animated.View`, etc.
+   *
+   * See https://reactnative.dev/docs/animated#createanimatedcomponent
+   */
+  createAnimatedComponent,
+  /**
+   * Imperative API to attach an animated value to an event on a view. Prefer
+   * using `Animated.event` with `useNativeDrive: true` if possible.
+   *
+   * See https://reactnative.dev/docs/animated#attachnativeevent
+   */
+  attachNativeEvent,
+  /**
+   * Advanced imperative API for snooping on animated events that are passed in
+   * through props. Use values directly where possible.
+   *
+   * See https://reactnative.dev/docs/animated#forkevent
+   */
+  forkEvent,
+  unforkEvent,
+  /**
+   * Expose Event class, so it can be used as a type for type checkers.
+   */
+  Event: AnimatedEvent
+};
 export { AnimatedImplementation_default as default };
 //# sourceMappingURL=AnimatedImplementation.mjs.map