@hanzogui/react-native-web-lite 2.0.0

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

@@ -0,0 +1,142 @@
+/**
+ * Portions 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
+ */
+
+/**
+ * BezierEasing - use bezier curve for transition easing function
+ * https://github.com/gre/bezier-easing
+ * @copyright 2014-2015 Gaëtan Renaudeau. MIT License.
+ */
+
+'use strict'
+
+// These values are established by empiricism with tests (tradeoff: performance VS precision)
+const NEWTON_ITERATIONS = 4
+const NEWTON_MIN_SLOPE = 0.001
+const SUBDIVISION_PRECISION = 0.0000001
+const SUBDIVISION_MAX_ITERATIONS = 10
+
+const kSplineTableSize = 11
+const kSampleStepSize = 1.0 / (kSplineTableSize - 1.0)
+
+const float32ArraySupported = typeof Float32Array === 'function'
+
+function A(aA1, aA2) {
+  return 1.0 - 3.0 * aA2 + 3.0 * aA1
+}
+function B(aA1, aA2) {
+  return 3.0 * aA2 - 6.0 * aA1
+}
+function C(aA1) {
+  return 3.0 * aA1
+}
+
+// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+function calcBezier(aT, aA1, aA2) {
+  return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT
+}
+
+// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+function getSlope(aT, aA1, aA2) {
+  return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1)
+}
+
+function binarySubdivide(aX, _aA, _aB, mX1, mX2) {
+  let currentX,
+    currentT,
+    i = 0,
+    aA = _aA,
+    aB = _aB
+  do {
+    currentT = aA + (aB - aA) / 2.0
+    currentX = calcBezier(currentT, mX1, mX2) - aX
+    if (currentX > 0.0) {
+      aB = currentT
+    } else {
+      aA = currentT
+    }
+  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS)
+  return currentT
+}
+
+function newtonRaphsonIterate(aX, _aGuessT, mX1, mX2) {
+  let aGuessT = _aGuessT
+  for (let i = 0; i < NEWTON_ITERATIONS; ++i) {
+    const currentSlope = getSlope(aGuessT, mX1, mX2)
+    if (currentSlope === 0.0) {
+      return aGuessT
+    }
+    const currentX = calcBezier(aGuessT, mX1, mX2) - aX
+    aGuessT -= currentX / currentSlope
+  }
+  return aGuessT
+}
+
+function bezier(mX1, mY1, mX2, mY2) {
+  if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
+    throw new Error('bezier x values must be in [0, 1] range')
+  }
+
+  // Precompute samples table
+  const sampleValues = float32ArraySupported
+    ? new Float32Array(kSplineTableSize)
+    : new Array(kSplineTableSize)
+  if (mX1 !== mY1 || mX2 !== mY2) {
+    for (let i = 0; i < kSplineTableSize; ++i) {
+      sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2)
+    }
+  }
+
+  function getTForX(aX) {
+    let intervalStart = 0.0
+    let currentSample = 1
+    const lastSample = kSplineTableSize - 1
+
+    for (
+      ;
+      currentSample !== lastSample && sampleValues[currentSample] <= aX;
+      ++currentSample
+    ) {
+      intervalStart += kSampleStepSize
+    }
+    --currentSample
+
+    // Interpolate to provide an initial guess for t
+    const dist =
+      (aX - sampleValues[currentSample]) /
+      (sampleValues[currentSample + 1] - sampleValues[currentSample])
+    const guessForT = intervalStart + dist * kSampleStepSize
+
+    const initialSlope = getSlope(guessForT, mX1, mX2)
+    if (initialSlope >= NEWTON_MIN_SLOPE) {
+      return newtonRaphsonIterate(aX, guessForT, mX1, mX2)
+    } else if (initialSlope === 0.0) {
+      return guessForT
+    } else {
+      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2)
+    }
+  }
+
+  return function BezierEasing(x) {
+    if (mX1 === mY1 && mX2 === mY2) {
+      return x // linear
+    }
+    // Because JavaScript number are imprecise, we should guarantee the extremes are right.
+    if (x === 0) {
+      return 0
+    }
+    if (x === 1) {
+      return 1
+    }
+    return calcBezier(getTForX(x), mY1, mY2)
+  }
+}
+
+export { bezier }
+export default bezier

package/src/vendor/react-native/Animated/components/AnimatedFlatList.jsx

@@ -0,0 +1,24 @@
+/**
+ * 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 * as React from 'react'
+
+import { FlatList as FlatListComponent } from '../../../../FlatList'
+import { createAnimatedComponent } from '../createAnimatedComponent'
+
+/**
+ * @see https://github.com/facebook/react-native/commit/b8c8562
+ */
+const FlatListWithEventThrottle = React.forwardRef((props, ref) => (
+  <FlatListComponent scrollEventThrottle={0.0001} {...props} ref={ref} />
+))
+
+const FlatList = createAnimatedComponent(FlatListWithEventThrottle)
+export { FlatList }
+export default FlatList

package/src/vendor/react-native/Animated/components/AnimatedImage.js

@@ -0,0 +1,17 @@
+/**
+ * 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 * as React from 'react'
+
+import { Image } from '../../../../Image'
+import { createAnimatedComponent } from '../createAnimatedComponent'
+
+const AnimatedImage = createAnimatedComponent(Image)
+export { AnimatedImage }
+export default AnimatedImage

package/src/vendor/react-native/Animated/components/AnimatedScrollView.jsx

@@ -0,0 +1,24 @@
+/**
+ * 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 * as React from 'react'
+
+import { ScrollView as ScrollViewComponent } from '../../../../ScrollView'
+import { createAnimatedComponent } from '../createAnimatedComponent'
+
+/**
+ * @see https://github.com/facebook/react-native/commit/b8c8562
+ */
+const ScrollViewWithEventThrottle = React.forwardRef((props, ref) => (
+  <ScrollViewComponent scrollEventThrottle={0.0001} {...props} ref={ref} />
+))
+
+const ScrollView = createAnimatedComponent(ScrollViewWithEventThrottle)
+export { ScrollView }
+export default ScrollView

package/src/vendor/react-native/Animated/components/AnimatedSectionList.jsx

@@ -0,0 +1,24 @@
+/**
+ * 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 * as React from 'react'
+
+import { SectionList as SectionListComponent } from '../../../../SectionList'
+import { createAnimatedComponent } from '../createAnimatedComponent'
+
+/**
+ * @see https://github.com/facebook/react-native/commit/b8c8562
+ */
+const SectionListWithEventThrottle = React.forwardRef((props, ref) => (
+  <SectionListComponent scrollEventThrottle={0.0001} {...props} ref={ref} />
+))
+
+const SectionList = createAnimatedComponent(SectionListWithEventThrottle)
+export { SectionList }
+export default SectionList

package/src/vendor/react-native/Animated/components/AnimatedText.js

@@ -0,0 +1,15 @@
+/**
+ * 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 { Text } from '../../../../Text'
+import { createAnimatedComponent } from '../createAnimatedComponent'
+
+const AnimatedText = createAnimatedComponent(Text)
+export { AnimatedText }
+export default AnimatedText

package/src/vendor/react-native/Animated/components/AnimatedView.js

@@ -0,0 +1,15 @@
+/**
+ * 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 { View } from '../../../../View'
+import { createAnimatedComponent } from '../createAnimatedComponent'
+
+const AnimatedView = createAnimatedComponent(View)
+export { AnimatedView }
+export default AnimatedView

package/src/vendor/react-native/Animated/createAnimatedComponent.jsx

@@ -0,0 +1,39 @@
+/**
+ * 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 { useAnimatedProps } from './useAnimatedProps'
+import { useMergeRefs } from '../Utilities/useMergeRefs'
+import * as React from 'react'
+
+/**
+ * Experimental implementation of `createAnimatedComponent` that is intended to
+ * be compatible with concurrent rendering.
+ */
+function createAnimatedComponent(Component) {
+  return React.forwardRef((props, forwardedRef) => {
+    const [reducedProps, callbackRef] = useAnimatedProps(props)
+    const ref = useMergeRefs(callbackRef, forwardedRef)
+
+    // Some components require explicit passthrough values for animation
+    // to work properly. For example, if an animated component is
+    // transformed and Pressable, onPress will not work after transform
+    // without these passthrough values.
+    const { passthroughAnimatedPropExplicitValues, style } = reducedProps
+    const { style: passthroughStyle, ...passthroughProps } =
+      passthroughAnimatedPropExplicitValues ?? {}
+    const mergedStyle = [style, passthroughStyle]
+
+    return (
+      <Component {...reducedProps} {...passthroughProps} style={mergedStyle} ref={ref} />
+    )
+  })
+}
+
+export { createAnimatedComponent }
+export default createAnimatedComponent

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

@@ -0,0 +1,60 @@
+/**
+ * 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 { AnimatedInterpolation } from './AnimatedInterpolation'
+import { AnimatedValue } from './AnimatedValue'
+import { AnimatedWithChildren } from './AnimatedWithChildren'
+
+class AnimatedAddition extends AnimatedWithChildren {
+  _a
+  _b
+
+  constructor(a, b) {
+    super()
+    this._a = typeof a === 'number' ? new AnimatedValue(a) : a
+    this._b = typeof b === 'number' ? new AnimatedValue(b) : b
+  }
+
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig)
+    this._b.__makeNative(platformConfig)
+    super.__makeNative(platformConfig)
+  }
+
+  __getValue() {
+    return this._a.__getValue() + this._b.__getValue()
+  }
+
+  interpolate(config) {
+    return new AnimatedInterpolation(this, config)
+  }
+
+  __attach() {
+    this._a.__addChild(this)
+    this._b.__addChild(this)
+  }
+
+  __detach() {
+    this._a.__removeChild(this)
+    this._b.__removeChild(this)
+    super.__detach()
+  }
+
+  __getNativeConfig() {
+    return {
+      type: 'addition',
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+    }
+  }
+}
+
+export { AnimatedAddition }
+export default AnimatedAddition

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

@@ -0,0 +1,293 @@
+/**
+ * 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
+ */
+
+import { AnimatedValue } from './AnimatedValue'
+import { AnimatedWithChildren } from './AnimatedWithChildren'
+import { normalizeColor } from '@hanzogui/react-native-web-internals'
+import { NativeAnimatedHelper } from '../NativeAnimatedHelper'
+
+const NativeAnimatedAPI = NativeAnimatedHelper.API
+
+const defaultColor = { r: 0, g: 0, b: 0, a: 1.0 }
+let _uniqueId = 1
+
+const processColorObject = (color) => {
+  return color
+}
+
+/* eslint no-bitwise: 0 */
+function processColor(color) {
+  if (color === undefined || color === null) {
+    return null
+  }
+
+  if (isRgbaValue(color)) {
+    return color
+  }
+
+  let normalizedColor = normalizeColor(color)
+  if (normalizedColor === undefined || normalizedColor === null) {
+    return null
+  }
+
+  if (typeof normalizedColor === 'object') {
+    const processedColorObj = processColorObject(normalizedColor)
+    if (processedColorObj != null) {
+      return processedColorObj
+    }
+  } else if (typeof normalizedColor === 'number') {
+    const r = (normalizedColor & 0xff000000) >>> 24
+    const g = (normalizedColor & 0x00ff0000) >>> 16
+    const b = (normalizedColor & 0x0000ff00) >>> 8
+    const a = (normalizedColor & 0x000000ff) / 255
+
+    return { r, g, b, a }
+  }
+
+  return null
+}
+
+function isRgbaValue(value) {
+  return (
+    value &&
+    typeof value.r === 'number' &&
+    typeof value.g === 'number' &&
+    typeof value.b === 'number' &&
+    typeof value.a === 'number'
+  )
+}
+
+function isRgbaAnimatedValue(value) {
+  return (
+    value &&
+    value.r instanceof AnimatedValue &&
+    value.g instanceof AnimatedValue &&
+    value.b instanceof AnimatedValue &&
+    value.a instanceof AnimatedValue
+  )
+}
+
+class AnimatedColor extends AnimatedWithChildren {
+  constructor(valueIn, config) {
+    super()
+    this._listeners = {}
+
+    let value = valueIn ?? defaultColor
+    if (isRgbaAnimatedValue(value)) {
+      const rgbaAnimatedValue = value
+      this.r = rgbaAnimatedValue.r
+      this.g = rgbaAnimatedValue.g
+      this.b = rgbaAnimatedValue.b
+      this.a = rgbaAnimatedValue.a
+    } else {
+      const processedColor = processColor(value) ?? defaultColor
+      let initColor = defaultColor
+      if (isRgbaValue(processedColor)) {
+        initColor = processedColor
+      } else {
+        this.nativeColor = processedColor
+      }
+
+      this.r = new AnimatedValue(initColor.r)
+      this.g = new AnimatedValue(initColor.g)
+      this.b = new AnimatedValue(initColor.b)
+      this.a = new AnimatedValue(initColor.a)
+    }
+    if (this.nativeColor || (config && config.useNativeDriver)) {
+      this.__makeNative()
+    }
+  }
+
+  /**
+   * Directly set the value. This will stop any animations running on the value
+   * and update all the bound properties.
+   */
+  setValue(value) {
+    let shouldUpdateNodeConfig = false
+    if (this.__isNative) {
+      const nativeTag = this.__getNativeTag()
+      NativeAnimatedAPI.setWaitingForIdentifier(nativeTag.toString())
+    }
+
+    const processedColor = processColor(value) ?? defaultColor
+    if (isRgbaValue(processedColor)) {
+      const rgbaValue = processedColor
+      this.r.setValue(rgbaValue.r)
+      this.g.setValue(rgbaValue.g)
+      this.b.setValue(rgbaValue.b)
+      this.a.setValue(rgbaValue.a)
+      if (this.nativeColor != null) {
+        this.nativeColor = null
+        shouldUpdateNodeConfig = true
+      }
+    } else {
+      const nativeColor = processedColor
+      if (this.nativeColor !== nativeColor) {
+        this.nativeColor = nativeColor
+        shouldUpdateNodeConfig = true
+      }
+    }
+
+    if (this.__isNative) {
+      const nativeTag = this.__getNativeTag()
+      if (shouldUpdateNodeConfig) {
+        NativeAnimatedAPI.updateAnimatedNodeConfig(nativeTag, this.__getNativeConfig())
+      }
+      NativeAnimatedAPI.unsetWaitingForIdentifier(nativeTag.toString())
+    }
+  }
+
+  /**
+   * 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.
+   */
+  setOffset(offset) {
+    this.r.setOffset(offset.r)
+    this.g.setOffset(offset.g)
+    this.b.setOffset(offset.b)
+    this.a.setOffset(offset.a)
+  }
+
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   */
+  flattenOffset() {
+    this.r.flattenOffset()
+    this.g.flattenOffset()
+    this.b.flattenOffset()
+    this.a.flattenOffset()
+  }
+
+  /**
+   * Sets the offset value to the base value, and resets the base value to
+   * zero. The final output of the value is unchanged.
+   */
+  extractOffset() {
+    this.r.extractOffset()
+    this.g.extractOffset()
+    this.b.extractOffset()
+    this.a.extractOffset()
+  }
+
+  /**
+   * 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.
+   */
+  addListener(callback) {
+    const id = String(_uniqueId++)
+    const jointCallback = ({ value }) => {
+      callback(this.__getValue())
+    }
+    this._listeners[id] = {
+      r: this.r.addListener(jointCallback),
+      g: this.g.addListener(jointCallback),
+      b: this.b.addListener(jointCallback),
+      a: this.a.addListener(jointCallback),
+    }
+    return id
+  }
+
+  removeListener(id) {
+    if (this._listeners[id]) {
+      this.r.removeListener(this._listeners[id].r)
+      this.g.removeListener(this._listeners[id].g)
+      this.b.removeListener(this._listeners[id].b)
+      this.a.removeListener(this._listeners[id].a)
+      delete this._listeners[id]
+    }
+  }
+
+  removeAllListeners() {
+    this.r.removeAllListeners()
+    this.g.removeAllListeners()
+    this.b.removeAllListeners()
+    this.a.removeAllListeners()
+    this._listeners = {}
+  }
+
+  stopAnimation(callback) {
+    this.r.stopAnimation()
+    this.g.stopAnimation()
+    this.b.stopAnimation()
+    this.a.stopAnimation()
+    callback && callback(this.__getValue())
+  }
+
+  resetAnimation(callback) {
+    this.r.resetAnimation()
+    this.g.resetAnimation()
+    this.b.resetAnimation()
+    this.a.resetAnimation()
+    callback && callback(this.__getValue())
+  }
+
+  interpolate(config) {
+    throw new Error(
+      'Directly calling interpolate on an AnimatedColor is not supported. ' +
+        'Call interpolate on the AnimatedColor.r/g/b/a values instead.'
+    )
+  }
+
+  __getValue() {
+    if (this.nativeColor != null) {
+      return this.nativeColor
+    } else {
+      return {
+        r: this.r.__getValue(),
+        g: this.g.__getValue(),
+        b: this.b.__getValue(),
+        a: this.a.__getValue(),
+      }
+    }
+  }
+
+  __attach() {
+    this.r.__addChild(this)
+    this.g.__addChild(this)
+    this.b.__addChild(this)
+    this.a.__addChild(this)
+    super.__attach()
+  }
+
+  __detach() {
+    this.r.__removeChild(this)
+    this.g.__removeChild(this)
+    this.b.__removeChild(this)
+    this.a.__removeChild(this)
+    super.__detach()
+  }
+
+  __makeNative(platformConfig) {
+    this.r.__makeNative(platformConfig)
+    this.g.__makeNative(platformConfig)
+    this.b.__makeNative(platformConfig)
+    this.a.__makeNative(platformConfig)
+    super.__makeNative(platformConfig)
+  }
+
+  __getNativeConfig() {
+    return {
+      type: 'color',
+      r: this.r.__getNativeTag(),
+      g: this.g.__getNativeTag(),
+      b: this.b.__getNativeTag(),
+      a: this.a.__getNativeTag(),
+      nativeColor: this.nativeColor,
+    }
+  }
+}
+
+export { AnimatedColor }
+export default AnimatedColor