@hanzogui/react-native-web-lite 2.0.0-rc.41-hanzoai.5

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

@@ -0,0 +1,88 @@
+/**
+ * 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
+ * @format
+ */
+
+const defaultSpringConfig = {
+  stiffness: 0,
+  damping: 0,
+}
+
+function stiffnessFromOrigamiValue(oValue) {
+  return (oValue - 30) * 3.62 + 194
+}
+
+function dampingFromOrigamiValue(oValue) {
+  return (oValue - 8) * 3 + 25
+}
+
+function fromOrigamiTensionAndFriction(tension, friction) {
+  return {
+    stiffness: stiffnessFromOrigamiValue(tension),
+    damping: dampingFromOrigamiValue(friction),
+  }
+}
+
+function fromBouncinessAndSpeed(bounciness, speed) {
+  function normalize(value, startValue, endValue) {
+    return (value - startValue) / (endValue - startValue)
+  }
+
+  function projectNormal(n, start, end) {
+    return start + n * (end - start)
+  }
+
+  function linearInterpolation(t, start, end) {
+    return t * end + (1 - t) * start
+  }
+
+  function quadraticOutInterpolation(t, start, end) {
+    return linearInterpolation(2 * t - t * t, start, end)
+  }
+
+  function b3Friction1(x) {
+    return 0.0007 * x ** 3 - 0.031 * x ** 2 + 0.64 * x + 1.28
+  }
+
+  function b3Friction2(x) {
+    return 0.000044 * x ** 3 - 0.006 * x ** 2 + 0.36 * x + 2
+  }
+
+  function b3Friction3(x) {
+    return 0.00000045 * x ** 3 - 0.000332 * x ** 2 + 0.1078 * x + 5.84
+  }
+
+  function b3Nobounce(tension) {
+    if (tension <= 18) {
+      return b3Friction1(tension)
+    } else if (tension > 18 && tension <= 44) {
+      return b3Friction2(tension)
+    } else {
+      return b3Friction3(tension)
+    }
+  }
+
+  let b = normalize(bounciness / 1.7, 0, 20)
+  b = projectNormal(b, 0, 0.8)
+  const s = normalize(speed / 1.7, 0, 20)
+  const bouncyTension = projectNormal(s, 0.5, 200)
+  const bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01)
+
+  return {
+    stiffness: stiffnessFromOrigamiValue(bouncyTension),
+    damping: dampingFromOrigamiValue(bouncyFriction),
+  }
+}
+
+const SpringConfig = {
+  fromOrigamiTensionAndFriction,
+  fromBouncinessAndSpeed,
+}
+
+export { SpringConfig }
+export default SpringConfig

package/src/vendor/react-native/Animated/animations/Animation.js

@@ -0,0 +1,66 @@
+/**
+ * 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'
+
+let startNativeAnimationNextId = 1
+
+// Important note: start() and stop() will only be called at most once.
+// Once an animation has been stopped or finished its course, it will
+// not be reused.
+class Animation {
+  __active
+  __isInteraction
+  __nativeId
+  __onEnd
+  __iterations
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {}
+  stop() {
+    if (this.__nativeId) {
+      NativeAnimatedHelper.API.stopAnimation(this.__nativeId)
+    }
+  }
+  __getNativeAnimationConfig() {
+    // Subclasses that have corresponding animation implementation done in native
+    // should override this method
+    throw new Error('This animation type cannot be offloaded to native')
+  }
+  // Helper function for subclasses to make sure onEnd is only called once.
+  __debouncedOnEnd(result) {
+    const onEnd = this.__onEnd
+    this.__onEnd = null
+    onEnd && onEnd(result)
+  }
+  __startNativeAnimation(animatedValue) {
+    const startNativeAnimationWaitId = `${startNativeAnimationNextId}:startAnimation`
+    startNativeAnimationNextId += 1
+    NativeAnimatedHelper.API.setWaitingForIdentifier(startNativeAnimationWaitId)
+    try {
+      const config = this.__getNativeAnimationConfig()
+      animatedValue.__makeNative(config.platformConfig)
+      this.__nativeId = NativeAnimatedHelper.generateNewAnimationId()
+      NativeAnimatedHelper.API.startAnimatingNode(
+        this.__nativeId,
+        animatedValue.__getNativeTag(),
+        config,
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+        this.__debouncedOnEnd.bind(this)
+      )
+    } catch (e) {
+      throw e
+    } finally {
+      NativeAnimatedHelper.API.unsetWaitingForIdentifier(startNativeAnimationWaitId)
+    }
+  }
+}
+
+export { Animation }
+export default Animation

package/src/vendor/react-native/Animated/animations/DecayAnimation.js

@@ -0,0 +1,88 @@
+/**
+ * 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 { Animation } from './Animation'
+
+import { shouldUseNativeDriver } from '../NativeAnimatedHelper'
+
+class DecayAnimation extends Animation {
+  _startTime
+  _lastValue
+  _fromValue
+  _deceleration
+  _velocity
+  _onUpdate
+  _animationFrame
+  _useNativeDriver
+
+  constructor(config) {
+    super()
+    this._deceleration = config.deceleration ?? 0.998
+    this._velocity = config.velocity
+    this._useNativeDriver = shouldUseNativeDriver(config)
+    this.__isInteraction = config.isInteraction ?? !this._useNativeDriver
+    this.__iterations = config.iterations ?? 1
+  }
+
+  __getNativeAnimationConfig() {
+    return {
+      type: 'decay',
+      deceleration: this._deceleration,
+      velocity: this._velocity,
+      iterations: this.__iterations,
+    }
+  }
+
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = true
+    this._lastValue = fromValue
+    this._fromValue = fromValue
+    this._onUpdate = onUpdate
+    this.__onEnd = onEnd
+    this._startTime = Date.now()
+    if (this._useNativeDriver) {
+      this.__startNativeAnimation(animatedValue)
+    } else {
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this))
+    }
+  }
+
+  onUpdate() {
+    const now = Date.now()
+
+    const value =
+      this._fromValue +
+      (this._velocity / (1 - this._deceleration)) *
+        (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)))
+
+    this._onUpdate(value)
+
+    if (Math.abs(this._lastValue - value) < 0.1) {
+      this.__debouncedOnEnd({ finished: true })
+      return
+    }
+
+    this._lastValue = value
+    if (this.__active) {
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this))
+    }
+  }
+
+  stop() {
+    super.stop()
+    this.__active = false
+    global.cancelAnimationFrame(this._animationFrame)
+    this.__debouncedOnEnd({ finished: false })
+  }
+}
+
+export { DecayAnimation }
+export default DecayAnimation

package/src/vendor/react-native/Animated/animations/SpringAnimation.js

@@ -0,0 +1,291 @@
+/**
+ * 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 { Animation } from './Animation'
+import { SpringConfig } from '../SpringConfig'
+
+import { invariant } from '@hanzogui/react-native-web-internals'
+
+import { shouldUseNativeDriver } from '../NativeAnimatedHelper'
+
+class SpringAnimation extends Animation {
+  _overshootClamping
+  _restDisplacementThreshold
+  _restSpeedThreshold
+  _lastVelocity
+  _startPosition
+  _lastPosition
+  _fromValue
+  _toValue
+  _stiffness
+  _damping
+  _mass
+  _initialVelocity
+  _delay
+  _timeout
+  _startTime
+  _lastTime
+  _frameTime
+  _onUpdate
+  _animationFrame
+  _useNativeDriver
+  _platformConfig
+
+  constructor(config) {
+    super()
+
+    this._overshootClamping = config.overshootClamping ?? false
+    this._restDisplacementThreshold = config.restDisplacementThreshold ?? 0.001
+    this._restSpeedThreshold = config.restSpeedThreshold ?? 0.001
+    this._initialVelocity = config.velocity ?? 0
+    this._lastVelocity = config.velocity ?? 0
+    this._toValue = config.toValue
+    this._delay = config.delay ?? 0
+    this._useNativeDriver = shouldUseNativeDriver(config)
+    this._platformConfig = config.platformConfig
+    this.__isInteraction = config.isInteraction ?? !this._useNativeDriver
+    this.__iterations = config.iterations ?? 1
+
+    if (
+      config.stiffness !== undefined ||
+      config.damping !== undefined ||
+      config.mass !== undefined
+    ) {
+      invariant(
+        config.bounciness === undefined &&
+          config.speed === undefined &&
+          config.tension === undefined &&
+          config.friction === undefined,
+        'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one'
+      )
+      this._stiffness = config.stiffness ?? 100
+      this._damping = config.damping ?? 10
+      this._mass = config.mass ?? 1
+    } else if (config.bounciness !== undefined || config.speed !== undefined) {
+      // Convert the origami bounciness/speed values to stiffness/damping
+      // We assume mass is 1.
+      invariant(
+        config.tension === undefined &&
+          config.friction === undefined &&
+          config.stiffness === undefined &&
+          config.damping === undefined &&
+          config.mass === undefined,
+        'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one'
+      )
+      const springConfig = SpringConfig.fromBouncinessAndSpeed(
+        config.bounciness ?? 8,
+        config.speed ?? 12
+      )
+      this._stiffness = springConfig.stiffness
+      this._damping = springConfig.damping
+      this._mass = 1
+    } else {
+      // Convert the origami tension/friction values to stiffness/damping
+      // We assume mass is 1.
+      const springConfig = SpringConfig.fromOrigamiTensionAndFriction(
+        config.tension ?? 40,
+        config.friction ?? 7
+      )
+      this._stiffness = springConfig.stiffness
+      this._damping = springConfig.damping
+      this._mass = 1
+    }
+
+    invariant(this._stiffness > 0, 'Stiffness value must be greater than 0')
+    invariant(this._damping > 0, 'Damping value must be greater than 0')
+    invariant(this._mass > 0, 'Mass value must be greater than 0')
+  }
+
+  __getNativeAnimationConfig() {
+    return {
+      type: 'spring',
+      overshootClamping: this._overshootClamping,
+      restDisplacementThreshold: this._restDisplacementThreshold,
+      restSpeedThreshold: this._restSpeedThreshold,
+      stiffness: this._stiffness,
+      damping: this._damping,
+      mass: this._mass,
+      initialVelocity: this._initialVelocity ?? this._lastVelocity,
+      toValue: this._toValue,
+      iterations: this.__iterations,
+      platformConfig: this._platformConfig,
+    }
+  }
+
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = true
+    this._startPosition = fromValue
+    this._lastPosition = this._startPosition
+
+    this._onUpdate = onUpdate
+    this.__onEnd = onEnd
+    this._lastTime = Date.now()
+    this._frameTime = 0.0
+
+    if (previousAnimation instanceof SpringAnimation) {
+      const internalState = previousAnimation.getInternalState()
+      this._lastPosition = internalState.lastPosition
+      this._lastVelocity = internalState.lastVelocity
+      // Set the initial velocity to the last velocity
+      this._initialVelocity = this._lastVelocity
+      this._lastTime = internalState.lastTime
+    }
+
+    const start = () => {
+      if (this._useNativeDriver) {
+        this.__startNativeAnimation(animatedValue)
+      } else {
+        this.onUpdate()
+      }
+    }
+
+    //  If this._delay is more than 0, we start after the timeout.
+    if (this._delay) {
+      this._timeout = setTimeout(start, this._delay)
+    } else {
+      start()
+    }
+  }
+
+  getInternalState() {
+    return {
+      lastPosition: this._lastPosition,
+      lastVelocity: this._lastVelocity,
+      lastTime: this._lastTime,
+    }
+  }
+
+  /**
+   * This spring model is based off of a damped harmonic oscillator
+   * (https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator).
+   *
+   * We use the closed form of the second order differential equation:
+   *
+   * x'' + (2ζ⍵_0)x' + ⍵^2x = 0
+   *
+   * where
+   *    ⍵_0 = √(k / m) (undamped angular frequency of the oscillator),
+   *    ζ = c / 2√mk (damping ratio),
+   *    c = damping constant
+   *    k = stiffness
+   *    m = mass
+   *
+   * The derivation of the closed form is described in detail here:
+   * http://planetmath.org/sites/default/files/texpdf/39745.pdf
+   *
+   * This algorithm happens to match the algorithm used by CASpringAnimation,
+   * a QuartzCore (iOS) API that creates spring animations.
+   */
+  onUpdate() {
+    // If for some reason we lost a lot of frames (e.g. process large payload or
+    // stopped in the debugger), we only advance by 4 frames worth of
+    // computation and will continue on the next frame. It's better to have it
+    // running at faster speed than jumping to the end.
+    const MAX_STEPS = 64
+    let now = Date.now()
+    if (now > this._lastTime + MAX_STEPS) {
+      now = this._lastTime + MAX_STEPS
+    }
+
+    const deltaTime = (now - this._lastTime) / 1000
+    this._frameTime += deltaTime
+
+    const c = this._damping
+    const m = this._mass
+    const k = this._stiffness
+    const v0 = -this._initialVelocity
+
+    const zeta = c / (2 * Math.sqrt(k * m)) // damping ratio
+    const omega0 = Math.sqrt(k / m) // undamped angular frequency of the oscillator (rad/ms)
+    const omega1 = omega0 * Math.sqrt(1.0 - zeta * zeta) // exponential decay
+    const x0 = this._toValue - this._startPosition // calculate the oscillation from x0 = 1 to x = 0
+
+    let position = 0.0
+    let velocity = 0.0
+    const t = this._frameTime
+    if (zeta < 1) {
+      // Under damped
+      const envelope = Math.exp(-zeta * omega0 * t)
+      position =
+        this._toValue -
+        envelope *
+          (((v0 + zeta * omega0 * x0) / omega1) * Math.sin(omega1 * t) +
+            x0 * Math.cos(omega1 * t))
+      // This looks crazy -- it's actually just the derivative of the
+      // oscillation function
+      velocity =
+        zeta *
+          omega0 *
+          envelope *
+          ((Math.sin(omega1 * t) * (v0 + zeta * omega0 * x0)) / omega1 +
+            x0 * Math.cos(omega1 * t)) -
+        envelope *
+          (Math.cos(omega1 * t) * (v0 + zeta * omega0 * x0) -
+            omega1 * x0 * Math.sin(omega1 * t))
+    } else {
+      // Critically damped
+      const envelope = Math.exp(-omega0 * t)
+      position = this._toValue - envelope * (x0 + (v0 + omega0 * x0) * t)
+      velocity = envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0))
+    }
+
+    this._lastTime = now
+    this._lastPosition = position
+    this._lastVelocity = velocity
+
+    this._onUpdate(position)
+    if (!this.__active) {
+      // a listener might have stopped us in _onUpdate
+      return
+    }
+
+    // Conditions for stopping the spring animation
+    let isOvershooting = false
+    if (this._overshootClamping && this._stiffness !== 0) {
+      if (this._startPosition < this._toValue) {
+        isOvershooting = position > this._toValue
+      } else {
+        isOvershooting = position < this._toValue
+      }
+    }
+    const isVelocity = Math.abs(velocity) <= this._restSpeedThreshold
+    let isDisplacement = true
+    if (this._stiffness !== 0) {
+      isDisplacement =
+        Math.abs(this._toValue - position) <= this._restDisplacementThreshold
+    }
+
+    if (isOvershooting || (isVelocity && isDisplacement)) {
+      if (this._stiffness !== 0) {
+        // Ensure that we end up with a round value
+        this._lastPosition = this._toValue
+        this._lastVelocity = 0
+        this._onUpdate(this._toValue)
+      }
+
+      this.__debouncedOnEnd({ finished: true })
+      return
+    }
+    // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+    this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this))
+  }
+
+  stop() {
+    super.stop()
+    this.__active = false
+    clearTimeout(this._timeout)
+    global.cancelAnimationFrame(this._animationFrame)
+    this.__debouncedOnEnd({ finished: false })
+  }
+}
+
+export { SpringAnimation }
+export default SpringAnimation

package/src/vendor/react-native/Animated/animations/TimingAnimation.js

@@ -0,0 +1,133 @@
+/**
+ * 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
+ */
+
+import { Easing } from '../Easing'
+
+import { Animation } from './Animation'
+
+import { shouldUseNativeDriver } from '../NativeAnimatedHelper'
+
+let _easeInOut
+function easeInOut() {
+  if (!_easeInOut) {
+    _easeInOut = Easing.inOut(Easing.ease)
+  }
+  return _easeInOut
+}
+
+class TimingAnimation extends Animation {
+  _startTime
+  _fromValue
+  _toValue
+  _duration
+  _delay
+  _easing
+  _onUpdate
+  _animationFrame
+  _timeout
+  _useNativeDriver
+  _platformConfig
+
+  constructor(config) {
+    super()
+    this._toValue = config.toValue
+    this._easing = config.easing ?? easeInOut()
+    this._duration = config.duration ?? 500
+    this._delay = config.delay ?? 0
+    this.__iterations = config.iterations ?? 1
+    this._useNativeDriver = shouldUseNativeDriver(config)
+    this._platformConfig = config.platformConfig
+    this.__isInteraction = config.isInteraction ?? !this._useNativeDriver
+  }
+
+  __getNativeAnimationConfig() {
+    const frameDuration = 1000.0 / 60.0
+    const frames = []
+    const numFrames = Math.round(this._duration / frameDuration)
+    for (let frame = 0; frame < numFrames; frame++) {
+      frames.push(this._easing(frame / numFrames))
+    }
+    frames.push(this._easing(1))
+    return {
+      type: 'frames',
+      frames,
+      toValue: this._toValue,
+      iterations: this.__iterations,
+      platformConfig: this._platformConfig,
+    }
+  }
+
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = true
+    this._fromValue = fromValue
+    this._onUpdate = onUpdate
+    this.__onEnd = onEnd
+
+    const start = () => {
+      // Animations that sometimes have 0 duration and sometimes do not
+      // still need to use the native driver when duration is 0 so as to
+      // not cause intermixed JS and native animations.
+      if (this._duration === 0 && !this._useNativeDriver) {
+        this._onUpdate(this._toValue)
+        this.__debouncedOnEnd({ finished: true })
+      } else {
+        this._startTime = Date.now()
+        if (this._useNativeDriver) {
+          this.__startNativeAnimation(animatedValue)
+        } else {
+          this._animationFrame = requestAnimationFrame(
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            this.onUpdate.bind(this)
+          )
+        }
+      }
+    }
+    if (this._delay) {
+      this._timeout = setTimeout(start, this._delay)
+    } else {
+      start()
+    }
+  }
+
+  onUpdate() {
+    const now = Date.now()
+    if (now >= this._startTime + this._duration) {
+      if (this._duration === 0) {
+        this._onUpdate(this._toValue)
+      } else {
+        this._onUpdate(
+          this._fromValue + this._easing(1) * (this._toValue - this._fromValue)
+        )
+      }
+      this.__debouncedOnEnd({ finished: true })
+      return
+    }
+
+    this._onUpdate(
+      this._fromValue +
+        this._easing((now - this._startTime) / this._duration) *
+          (this._toValue - this._fromValue)
+    )
+    if (this.__active) {
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this))
+    }
+  }
+
+  stop() {
+    super.stop()
+    this.__active = false
+    clearTimeout(this._timeout)
+    global.cancelAnimationFrame(this._animationFrame)
+    this.__debouncedOnEnd({ finished: false })
+  }
+}
+
+export { TimingAnimation }
+export default TimingAnimation