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

package/dist/cjs/vendor/react-native/Animated/AnimatedImplementation.cjs

@@ -37,23 +37,25 @@ __export(AnimatedImplementation_exports, {
 });
 module.exports = __toCommonJS(AnimatedImplementation_exports);
 var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
-  import_DecayAnimation = __toESM(require("./animations/DecayAnimation.cjs")),
-  import_SpringAnimation = __toESM(require("./animations/SpringAnimation.cjs")),
-  import_TimingAnimation = __toESM(require("./animations/TimingAnimation.cjs")),
-  import_createAnimatedComponent = __toESM(require("./createAnimatedComponent.cjs")),
   import_AnimatedAddition = __toESM(require("./nodes/AnimatedAddition.cjs")),
-  import_AnimatedColor = __toESM(require("./nodes/AnimatedColor.cjs")),
   import_AnimatedDiffClamp = __toESM(require("./nodes/AnimatedDiffClamp.cjs")),
   import_AnimatedDivision = __toESM(require("./nodes/AnimatedDivision.cjs")),
   import_AnimatedInterpolation = __toESM(require("./nodes/AnimatedInterpolation.cjs")),
   import_AnimatedModulo = __toESM(require("./nodes/AnimatedModulo.cjs")),
   import_AnimatedMultiplication = __toESM(require("./nodes/AnimatedMultiplication.cjs")),
   import_AnimatedNode = __toESM(require("./nodes/AnimatedNode.cjs")),
+  import_AnimatedProps = require("./nodes/AnimatedProps.cjs"),
   import_AnimatedSubtraction = __toESM(require("./nodes/AnimatedSubtraction.cjs")),
   import_AnimatedTracking = __toESM(require("./nodes/AnimatedTracking.cjs")),
   import_AnimatedValue = __toESM(require("./nodes/AnimatedValue.cjs")),
   import_AnimatedValueXY = __toESM(require("./nodes/AnimatedValueXY.cjs")),
-  add = function (a, b) {
+  import_DecayAnimation = __toESM(require("./animations/DecayAnimation.cjs")),
+  import_SpringAnimation = __toESM(require("./animations/SpringAnimation.cjs")),
+  import_TimingAnimation = __toESM(require("./animations/TimingAnimation.cjs")),
+  import_createAnimatedComponent = __toESM(require("./createAnimatedComponent.cjs")),
+  import_Animation = require("./animations/Animation.cjs"),
+  import_AnimatedColor = __toESM(require("./nodes/AnimatedColor.cjs"));
+const add = function (a, b) {
     return new import_AnimatedAddition.default(a, b);
   },
   subtract = function (a, b) {
@@ -72,31 +74,32 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
     return new import_AnimatedDiffClamp.default(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 import_AnimatedValueXY.default) {
-      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 import_AnimatedColor.default) {
-      var configR = {
+      const configR = {
           ...config
         },
         configG = {
@@ -108,15 +111,16 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
         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);
@@ -126,16 +130,16 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
     }
     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 import_AnimatedNode.default ? singleValue.track(new import_AnimatedTracking.default(singleValue, configuration.toValue, import_SpringAnimation.default, singleConfig, callback)) : singleValue.animate(new import_SpringAnimation.default(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();
@@ -144,27 +148,27 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
         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 import_AnimatedNode.default ? singleValue.track(new import_AnimatedTracking.default(singleValue, configuration.toValue, import_TimingAnimation.default, singleConfig, callback)) : singleValue.animate(new import_TimingAnimation.default(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();
@@ -173,27 +177,27 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
         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 import_DecayAnimation.default(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();
@@ -202,11 +206,11 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
         value.resetAnimation();
       },
       _startNativeLoop: function (iterations) {
-        var singleConfig = {
+        const singleConfig = {
           ...config,
           iterations
         };
-        _start3(value, singleConfig);
+        start(value, singleConfig);
       },
       _isUsingNativeDriver: function () {
         return config.useNativeDriver || !1;
@@ -214,10 +218,10 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
     };
   },
   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;
@@ -226,7 +230,7 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
             callback && callback(result);
             return;
           }
-          animations[current].start(onComplete2);
+          animations[current].start(onComplete);
         };
         animations.length === 0 ? callback && callback({
           finished: !0
@@ -249,8 +253,8 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
     };
   },
   parallel = function (animations, config) {
-    var doneCount = 0,
-      hasEnded = {},
+    let doneCount = 0;
+    const hasEnded = {},
       stopTogether = !(config && config.stopTogether === !1),
       result = {
         start: function (callback) {
@@ -261,7 +265,7 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
             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;
@@ -303,20 +307,18 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
   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
@@ -336,179 +338,179 @@ var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
       }
     };
   };
-function forkEvent(event3, listener) {
-  return event3 ? event3 instanceof import_AnimatedEvent.AnimatedEvent ? (event3.__addListener(listener), event3) : function () {
-    typeof event3 == "function" && event3(...arguments), listener(...arguments);
+function forkEvent(event2, listener) {
+  return event2 ? event2 instanceof import_AnimatedEvent.AnimatedEvent ? (event2.__addListener(listener), event2) : (...args) => {
+    typeof event2 == "function" && event2(...args), listener(...args);
   } : listener;
 }
-function unforkEvent(event3, listener) {
-  event3 && event3 instanceof import_AnimatedEvent.AnimatedEvent && event3.__removeListener(listener);
+function unforkEvent(event2, listener) {
+  event2 && event2 instanceof import_AnimatedEvent.AnimatedEvent && event2.__removeListener(listener);
 }
-var event = function (argMapping, config) {
-    var animatedEvent = new import_AnimatedEvent.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: import_AnimatedValue.default,
-    /**
-     * 2D value class for driving 2D animations, such as pan gestures.
-     *
-     * See https://reactnative.dev/docs/animatedvaluexy
-     */
-    ValueXY: import_AnimatedValueXY.default,
-    /**
-     * Value class for driving color animations.
-     */
-    Color: import_AnimatedColor.default,
-    /**
-     * Exported to use the Interpolation type in flow.
-     *
-     * See https://reactnative.dev/docs/animated#interpolation
-     */
-    Interpolation: import_AnimatedInterpolation.default,
-    /**
-     * Exported for ease of type checking. All animated values derive from this
-     * class.
-     *
-     * See https://reactnative.dev/docs/animated#node
-     */
-    Node: import_AnimatedNode.default,
-    /**
-     * 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: import_createAnimatedComponent.default,
-    /**
-     * 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: import_AnimatedEvent.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: import_AnimatedEvent.AnimatedEvent
-  };
+const event = function (argMapping, config) {
+  const animatedEvent = new import_AnimatedEvent.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: import_AnimatedValue.default,
+  /**
+   * 2D value class for driving 2D animations, such as pan gestures.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy
+   */
+  ValueXY: import_AnimatedValueXY.default,
+  /**
+   * Value class for driving color animations.
+   */
+  Color: import_AnimatedColor.default,
+  /**
+   * Exported to use the Interpolation type in flow.
+   *
+   * See https://reactnative.dev/docs/animated#interpolation
+   */
+  Interpolation: import_AnimatedInterpolation.default,
+  /**
+   * Exported for ease of type checking. All animated values derive from this
+   * class.
+   *
+   * See https://reactnative.dev/docs/animated#node
+   */
+  Node: import_AnimatedNode.default,
+  /**
+   * 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: import_createAnimatedComponent.default,
+  /**
+   * 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: import_AnimatedEvent.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: import_AnimatedEvent.AnimatedEvent
+};