@tamagui/react-native-web-lite 1.112.5

package/src/vendor/react-native/Animated/nodes/AnimatedTransform.js

@@ -0,0 +1,130 @@
+/**
+ * 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'
+
+import NativeAnimatedHelper from '../NativeAnimatedHelper'
+import AnimatedNode from './AnimatedNode'
+import AnimatedWithChildren from './AnimatedWithChildren'
+
+class AnimatedTransform extends AnimatedWithChildren {
+  constructor(transforms) {
+    super()
+    this._transforms = transforms || []
+  }
+
+  __makeNative() {
+    this._transforms.forEach((transform) => {
+      for (var key in transform) {
+        var value = transform[key]
+
+        if (value instanceof AnimatedNode) {
+          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) {
+          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) {
+          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) {
+          value.__addChild(this)
+        }
+      }
+    })
+  }
+
+  __detach() {
+    this._transforms.forEach((transform) => {
+      for (var key in transform) {
+        var value = transform[key]
+
+        if (value instanceof AnimatedNode) {
+          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) {
+          transConfigs.push({
+            type: 'animated',
+            property: key,
+            nodeTag: value.__getNativeTag(),
+          })
+        } else {
+          transConfigs.push({
+            type: 'static',
+            property: key,
+            value: NativeAnimatedHelper.transformDataType(value),
+          })
+        }
+      }
+    })
+
+    NativeAnimatedHelper.validateTransform(transConfigs)
+    return {
+      type: 'transform',
+      transforms: transConfigs,
+    }
+  }
+}
+
+export default AnimatedTransform

package/src/vendor/react-native/Animated/nodes/AnimatedValue.js

@@ -0,0 +1,317 @@
+/**
+ * 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'
+
+import { InteractionManager } from '@tamagui/react-native-web-internals'
+
+import NativeAnimatedHelper from '../NativeAnimatedHelper'
+import AnimatedInterpolation from './AnimatedInterpolation'
+import AnimatedWithChildren from './AnimatedWithChildren'
+
+var NativeAnimatedAPI = NativeAnimatedHelper.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 {
+  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(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.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.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,
+    }
+  }
+}
+
+export default AnimatedValue

package/src/vendor/react-native/Animated/nodes/AnimatedValueXY.js

@@ -0,0 +1,200 @@
+/**
+ * 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'
+
+import { invariant } from '@tamagui/react-native-web-internals'
+
+import AnimatedValue from './AnimatedValue'
+import AnimatedWithChildren from './AnimatedWithChildren'
+var _uniqueId = 1
+/**
+ * 2D Value for driving 2D animations, such as pan gestures. Almost identical
+ * API to normal `Animated.Value`, but multiplexed.
+ *
+ * See https://reactnative.dev/docs/animatedvaluexy.html
+ */
+
+class AnimatedValueXY extends AnimatedWithChildren {
+  constructor(valueIn) {
+    super()
+    var value = valueIn || {
+      x: 0,
+      y: 0,
+    } // fixme: shouldn't need `: any`
+
+    if (typeof value.x === 'number' && typeof value.y === 'number') {
+      this.x = new AnimatedValue(value.x)
+      this.y = new AnimatedValue(value.y)
+    } else {
+      invariant(
+        value.x instanceof AnimatedValue && value.y instanceof AnimatedValue,
+        'AnimatedValueXY must be initialized with an object of numbers or ' +
+          'AnimatedValues.'
+      )
+      this.x = value.x
+      this.y = value.y
+    }
+
+    this._listeners = {}
+  }
+  /**
+   * Directly set the value. This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#setvalue
+   */
+
+  setValue(value) {
+    this.x.setValue(value.x)
+    this.y.setValue(value.y)
+  }
+  /**
+   * 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/animatedvaluexy.html#setoffset
+   */
+
+  setOffset(offset) {
+    this.x.setOffset(offset.x)
+    this.y.setOffset(offset.y)
+  }
+  /**
+   * 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/animatedvaluexy.html#flattenoffset
+   */
+
+  flattenOffset() {
+    this.x.flattenOffset()
+    this.y.flattenOffset()
+  }
+  /**
+   * 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/animatedvaluexy.html#extractoffset
+   */
+
+  extractOffset() {
+    this.x.extractOffset()
+    this.y.extractOffset()
+  }
+
+  __getValue() {
+    return {
+      x: this.x.__getValue(),
+      y: this.y.__getValue(),
+    }
+  }
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#resetanimation
+   */
+
+  resetAnimation(callback) {
+    this.x.resetAnimation()
+    this.y.resetAnimation()
+    callback && callback(this.__getValue())
+  }
+  /**
+   * 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/animatedvaluexy.html#stopanimation
+   */
+
+  stopAnimation(callback) {
+    this.x.stopAnimation()
+    this.y.stopAnimation()
+    callback && callback(this.__getValue())
+  }
+  /**
+   * Adds an asynchronous listener to the value so you can observe updates from
+   * animations.  This is useful because there is no way to synchronously read
+   * the value because it might be driven natively.
+   *
+   * Returns a string that serves as an identifier for the listener.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#addlistener
+   */
+
+  addListener(callback) {
+    var id = String(_uniqueId++)
+
+    var jointCallback = (_ref) => {
+      var number = _ref.value
+      callback(this.__getValue())
+    }
+
+    this._listeners[id] = {
+      x: this.x.addListener(jointCallback),
+      y: this.y.addListener(jointCallback),
+    }
+    return id
+  }
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#removelistener
+   */
+
+  removeListener(id) {
+    this.x.removeListener(this._listeners[id].x)
+    this.y.removeListener(this._listeners[id].y)
+    delete this._listeners[id]
+  }
+  /**
+   * Remove all registered listeners.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#removealllisteners
+   */
+
+  removeAllListeners() {
+    this.x.removeAllListeners()
+    this.y.removeAllListeners()
+    this._listeners = {}
+  }
+  /**
+   * Converts `{x, y}` into `{left, top}` for use in style.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#getlayout
+   */
+
+  getLayout() {
+    return {
+      left: this.x,
+      top: this.y,
+    }
+  }
+  /**
+   * Converts `{x, y}` into a useable translation transform.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#gettranslatetransform
+   */
+
+  getTranslateTransform() {
+    return [
+      {
+        translateX: this.x,
+      },
+      {
+        translateY: this.y,
+      },
+    ]
+  }
+}
+
+export default AnimatedValueXY