react-native-tvos 0.75.2-0rc0 → 0.76.0-0rc0

package/ReactAndroid/src/main/java/com/facebook/react/animated/AnimatedNode.kt

@@ -0,0 +1,74 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.animated
+
+import java.util.ArrayList
+
+/** Base class for all Animated.js library node types that can be created on the "native" side. */
+public abstract class AnimatedNode {
+
+  public companion object {
+    public const val INITIAL_BFS_COLOR: Int = 0
+    public const val DEFAULT_ANIMATED_NODE_CHILD_COUNT: Int = 1
+  }
+
+  // TODO: T196787278 Reduce the visibility of these fields to package once we have
+  // converted the whole module to Kotlin
+
+  @JvmField
+  internal var children: MutableList<AnimatedNode>? =
+      null /* lazy-initialized when a child is added */
+  @JvmField internal var activeIncomingNodes: Int = 0
+  @JvmField internal var BFSColor: Int = INITIAL_BFS_COLOR
+  @JvmField internal var tag: Int = -1
+
+  public fun addChild(child: AnimatedNode): Unit {
+    val currentChildren =
+        children
+            ?: ArrayList<AnimatedNode>(DEFAULT_ANIMATED_NODE_CHILD_COUNT).also { children = it }
+
+    currentChildren.add(child)
+    child.onAttachedToNode(this)
+  }
+
+  public fun removeChild(child: AnimatedNode): Unit {
+    val currentChildren = children ?: return
+    child.onDetachedFromNode(this)
+    currentChildren.remove(child)
+  }
+
+  /**
+   * Subclasses may want to override this method in order to store a reference to the parent of a
+   * given node that can then be used to calculate current node's value in {@link #update}. In that
+   * case it is important to also override {@link #onDetachedFromNode} to clear that reference once
+   * current node gets detached.
+   */
+  public open fun onAttachedToNode(parent: AnimatedNode): Unit = Unit
+
+  /** See {@link #onAttachedToNode} */
+  public open fun onDetachedFromNode(parent: AnimatedNode): Unit = Unit
+
+  /**
+   * This method will be run on each node at most once every repetition of the animation loop. It
+   * will be executed on a node only when all the node's parent has already been updated. Therefore
+   * it can be used to calculate node's value.
+   */
+  public open fun update(): Unit = Unit
+
+  /**
+   * Pretty-printer for the AnimatedNode. Only called in production pre-crash for debug diagnostics.
+   */
+  public abstract fun prettyPrint(): String
+
+  public fun prettyPrintWithChildren(): String {
+
+    val currentChildren = children?.joinToString(" ")
+    return prettyPrint() +
+        if (!currentChildren.isNullOrBlank()) " children: $currentChildren" else ""
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/AnimatedNodeValueListener.kt

@@ -0,0 +1,13 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.animated
+
+/** Interface used to listen to [ValueAnimatedNode] updates. */
+public fun interface AnimatedNodeValueListener {
+  public fun onValueUpdate(value: Double)
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/{AnimatedNodeWithUpdateableConfig.java → AnimatedNodeWithUpdateableConfig.kt}

@@ -5,11 +5,11 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.animated;
+package com.facebook.react.animated
 
-import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMap
 
 /** Indicates that AnimatedNode is able to receive native config updates. */
-interface AnimatedNodeWithUpdateableConfig {
-  void onUpdateConfig(ReadableMap config);
+public fun interface AnimatedNodeWithUpdateableConfig {
+  public fun onUpdateConfig(config: ReadableMap?)
 }

package/ReactAndroid/src/main/java/com/facebook/react/animated/{AnimationDriver.java → AnimationDriver.kt}

@@ -5,28 +5,27 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.animated;
+package com.facebook.react.animated
 
-import com.facebook.react.bridge.Callback;
-import com.facebook.react.bridge.JSApplicationCausedNativeException;
-import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.JSApplicationCausedNativeException
+import com.facebook.react.bridge.ReadableMap
 
 /**
  * Base class for different types of animation drivers. Can be used to implement simple time-based
  * animations as well as spring based animations.
  */
-/*package*/ abstract class AnimationDriver {
-
-  /*package*/ boolean mHasFinished = false;
-  /*package*/ ValueAnimatedNode mAnimatedValue;
-  /*package*/ Callback mEndCallback;
-  /*package*/ int mId;
+internal abstract class AnimationDriver {
+  @JvmField internal var hasFinished = false
+  @JvmField internal var animatedValue: ValueAnimatedNode? = null
+  @JvmField internal var endCallback: Callback? = null
+  @JvmField internal var id = 0
 
   /**
    * This method gets called in the main animation loop with a frame time passed down from the
    * android choreographer callback.
    */
-  public abstract void runAnimationStep(long frameTimeNanos);
+  abstract fun runAnimationStep(frameTimeNanos: Long)
 
   /**
    * This method will get called when some of the configuration gets updated while the animation is
@@ -34,8 +33,8 @@ import com.facebook.react.bridge.ReadableMap;
    * transition. E.g. in case of a spring animation we want to keep the current value and speed and
    * start animating with the new properties (different destination or spring settings)
    */
-  public void resetConfig(ReadableMap config) {
-    throw new JSApplicationCausedNativeException(
-        "Animation config for " + getClass().getSimpleName() + " cannot be reset");
+  open fun resetConfig(config: ReadableMap) {
+    throw JSApplicationCausedNativeException(
+        "Animation config for ${javaClass.simpleName} cannot be reset")
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/animated/ColorAnimatedNode.kt

@@ -0,0 +1,111 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.animated
+
+import android.content.Context
+import android.graphics.Color
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.views.view.ColorUtil.normalize
+
+/** Animated node that represents a color. */
+internal class ColorAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager,
+    private val reactApplicationContext: ReactApplicationContext
+) : AnimatedNode(), AnimatedNodeWithUpdateableConfig {
+  private var rNodeId = 0
+  private var gNodeId = 0
+  private var bNodeId = 0
+  private var aNodeId = 0
+  private var nativeColor: ReadableMap? = null
+  private var nativeColorApplied = false
+
+  init {
+    onUpdateConfig(config)
+  }
+
+  val color: Int
+    get() {
+      tryApplyNativeColor()
+      val rNode = nativeAnimatedNodesManager.getNodeById(rNodeId) as ValueAnimatedNode?
+      val gNode = nativeAnimatedNodesManager.getNodeById(gNodeId) as ValueAnimatedNode?
+      val bNode = nativeAnimatedNodesManager.getNodeById(bNodeId) as ValueAnimatedNode?
+      val aNode = nativeAnimatedNodesManager.getNodeById(aNodeId) as ValueAnimatedNode?
+      val r = rNode?.nodeValue ?: 0.0
+      val g = gNode?.nodeValue ?: 0.0
+      val b = bNode?.nodeValue ?: 0.0
+      val a = aNode?.nodeValue ?: 0.0
+      return normalize(r, g, b, a)
+    }
+
+  override fun onUpdateConfig(config: ReadableMap?) {
+    if (config != null) {
+      rNodeId = config.getInt("r")
+      gNodeId = config.getInt("g")
+      bNodeId = config.getInt("b")
+      aNodeId = config.getInt("a")
+      nativeColor = config.getMap("nativeColor")
+      nativeColorApplied = false
+      tryApplyNativeColor()
+    } else {
+      rNodeId = 0
+      gNodeId = 0
+      bNodeId = 0
+      aNodeId = 0
+      nativeColor = null
+      nativeColorApplied = false
+    }
+  }
+
+  override fun prettyPrint(): String =
+      "ColorAnimatedNode[$tag]: r: $rNodeId  g: $gNodeId b: $bNodeId a: $aNodeId"
+
+  private fun tryApplyNativeColor() {
+    if (nativeColor == null || nativeColorApplied) {
+      return
+    }
+    val context = context ?: return
+    val color = ColorPropConverter.getColor(nativeColor, context)
+    val rNode = nativeAnimatedNodesManager.getNodeById(rNodeId) as ValueAnimatedNode?
+    val gNode = nativeAnimatedNodesManager.getNodeById(gNodeId) as ValueAnimatedNode?
+    val bNode = nativeAnimatedNodesManager.getNodeById(bNodeId) as ValueAnimatedNode?
+    val aNode = nativeAnimatedNodesManager.getNodeById(aNodeId) as ValueAnimatedNode?
+    rNode?.nodeValue = Color.red(color).toDouble()
+    gNode?.nodeValue = Color.green(color).toDouble()
+    bNode?.nodeValue = Color.blue(color).toDouble()
+    aNode?.nodeValue = Color.alpha(color) / 255.0
+    nativeColorApplied = true
+  }
+
+  private val context: Context?
+    get() {
+      // There are cases where the activity may not exist (such as for VRShell panel apps). In this
+      // case we will search for a view associated with a PropsAnimatedNode to get the context.
+      return reactApplicationContext.currentActivity ?: getContextHelper(this)
+    }
+
+  companion object {
+    private fun getContextHelper(node: AnimatedNode): Context? {
+      // Search children depth-first until we get to a PropsAnimatedNode, from which we can
+      // get the view and its context
+      node.children?.let { children ->
+        for (child in children) {
+          return if (child is PropsAnimatedNode) {
+            val view = child.connectedView
+            view?.context
+          } else {
+            getContextHelper(child)
+          }
+        }
+      }
+      return null
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/DecayAnimation.kt

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.animated
+
+import com.facebook.react.bridge.ReadableMap
+import kotlin.math.abs
+import kotlin.math.exp
+
+/**
+ * Implementation of [AnimationDriver] providing support for decay animations. The implementation is
+ * copied from the JS version in `AnimatedImplementation.js`.
+ */
+internal class DecayAnimation(config: ReadableMap) : AnimationDriver() {
+  private var velocity: Double = 0.0
+  private var deceleration: Double = 0.0
+  private var startFrameTimeMillis: Long = -1
+  private var fromValue: Double = 0.0
+  private var lastValue: Double = 0.0
+  private var iterations: Int = 1
+  private var currentLoop: Int = 1
+
+  init {
+    resetConfig(config)
+  }
+
+  public override fun resetConfig(config: ReadableMap): Unit {
+    velocity = config.getDouble("velocity")
+    deceleration = config.getDouble("deceleration")
+    startFrameTimeMillis = -1
+    fromValue = 0.0
+    lastValue = 0.0
+    iterations = if (config.hasKey("iterations")) config.getInt("iterations") else 1
+    currentLoop = 1
+    hasFinished = iterations == 0
+  }
+
+  public override fun runAnimationStep(frameTimeNanos: Long) {
+    val animatedValue = requireNotNull(animatedValue) { "Animated value should not be null" }
+    val frameTimeMillis = frameTimeNanos / 1000000
+    if (startFrameTimeMillis == -1L) {
+      // since this is the first animation step, consider the start to be on the previous frame
+      startFrameTimeMillis = frameTimeMillis - 16
+      if (fromValue == lastValue) { // first iteration, assign [fromValue] based on [animatedValue]
+        fromValue = animatedValue.nodeValue
+      } else { // not the first iteration, reset [animatedValue] based on [fromValue]
+        animatedValue.nodeValue = fromValue
+      }
+      lastValue = animatedValue.nodeValue
+    }
+    val value =
+        (fromValue +
+            velocity / (1 - deceleration) *
+                (1 - exp(-(1 - deceleration) * (frameTimeMillis - startFrameTimeMillis))))
+    if (abs(lastValue - value) < 0.1) {
+      if (iterations == -1 || currentLoop < iterations) { // looping animation, return to start
+        // set [startFrameTimeMillis] to -1 to reset instance variables on the next
+        // [runAnimationStep]
+        startFrameTimeMillis = -1
+        currentLoop++
+      } else { // animation has completed
+        hasFinished = true
+        return
+      }
+    }
+    lastValue = value
+    animatedValue.nodeValue = value
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/DiffClampAnimatedNode.kt

@@ -0,0 +1,51 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.animated
+
+import com.facebook.react.bridge.JSApplicationCausedNativeException
+import com.facebook.react.bridge.ReadableMap
+import kotlin.math.max
+import kotlin.math.min
+
+internal class DiffClampAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : ValueAnimatedNode() {
+  private val inputNodeTag: Int
+  private val minValue: Double
+  private val maxValue: Double
+  private var lastValue: Double = 0.0
+
+  init {
+    inputNodeTag = config.getInt("input")
+    minValue = config.getDouble("min")
+    maxValue = config.getDouble("max")
+    nodeValue = lastValue
+  }
+
+  override fun update() {
+    val value = inputNodeValue
+    val diff = value - lastValue
+    lastValue = value
+    nodeValue = min(max(nodeValue + diff, minValue), maxValue)
+  }
+
+  private val inputNodeValue: Double
+    get() {
+      val animatedNode = nativeAnimatedNodesManager.getNodeById(inputNodeTag)
+      if (animatedNode == null || animatedNode !is ValueAnimatedNode) {
+        throw JSApplicationCausedNativeException(
+            "Illegal node ID set as an input for Animated.DiffClamp node")
+      }
+      return animatedNode.getValue()
+    }
+
+  override fun prettyPrint(): String =
+      "DiffClampAnimatedNode[$tag]: InputNodeTag: $inputNodeTag min: $minValue " +
+          "max: $maxValue lastValue: $lastValue super: ${super.prettyPrint()}"
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/DivisionAnimatedNode.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.animated
+
+import com.facebook.react.bridge.JSApplicationCausedNativeException
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Animated node which takes two or more value node as an input and outputs an in-order division of
+ * their values.
+ */
+internal class DivisionAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : ValueAnimatedNode() {
+  private val inputNodes: IntArray
+
+  init {
+    val input = config.getArray("input")
+    inputNodes =
+        if (input == null) {
+          IntArray(0)
+        } else {
+          IntArray(input.size()) { i -> input.getInt(i) }
+        }
+  }
+
+  override fun update() {
+    inputNodes.forEachIndexed { i, inputNode ->
+      val animatedNode = nativeAnimatedNodesManager.getNodeById(inputNode)
+      if (animatedNode != null && animatedNode is ValueAnimatedNode) {
+        val v = animatedNode.nodeValue
+        if (i == 0) {
+          nodeValue = v
+        } else if (v == 0.0) {
+          throw JSApplicationCausedNativeException(
+              "Detected a division by zero in Animated.divide node with Animated ID $tag")
+        } else {
+          nodeValue /= v
+        }
+      } else {
+        throw JSApplicationCausedNativeException(
+            "Illegal node ID set as an input for Animated.divide node with Animated ID $tag")
+      }
+    }
+  }
+
+  override fun prettyPrint(): String =
+      "DivisionAnimatedNode[$tag]: input nodes: $inputNodes - super: ${super.prettyPrint()}"
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/EventAnimationDriver.kt

@@ -0,0 +1,100 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.animated
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.UnexpectedNativeTypeException
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.EventCategoryDef
+import com.facebook.react.uimanager.events.RCTModernEventEmitter
+import com.facebook.react.uimanager.events.TouchEvent
+
+/** Handles updating a [ValueAnimatedNode] when an event gets dispatched. */
+internal class EventAnimationDriver(
+    @JvmField var eventName: String,
+    @JvmField internal var viewTag: Int,
+    private val eventPath: List<String>,
+    @JvmField internal var valueNode: ValueAnimatedNode
+) : RCTModernEventEmitter {
+  override fun receiveEvent(targetReactTag: Int, eventName: String, event: WritableMap?) =
+      receiveEvent(-1, targetReactTag, eventName, event)
+
+  override fun receiveEvent(
+      surfaceId: Int,
+      targetTag: Int,
+      eventName: String,
+      event: WritableMap?
+  ) =
+      // We assume this event can't be coalesced. `customCoalesceKey` has no meaning in Fabric.
+      receiveEvent(surfaceId, targetTag, eventName, false, 0, event, EventCategoryDef.UNSPECIFIED)
+
+  override fun receiveTouches(
+      eventName: String,
+      touches: WritableArray,
+      changedIndices: WritableArray
+  ) {
+    throw UnsupportedOperationException("receiveTouches is not support by native animated events")
+  }
+
+  override fun receiveTouches(touchEvent: TouchEvent) {
+    throw UnsupportedOperationException("receiveTouches is not support by native animated events")
+  }
+
+  override fun receiveEvent(
+      surfaceId: Int,
+      targetTag: Int,
+      eventName: String,
+      canCoalesceEvent: Boolean,
+      customCoalesceKey: Int,
+      event: WritableMap?,
+      @EventCategoryDef category: Int
+  ) {
+    requireNotNull(event) { "Native animated events must have event data." }
+
+    // Get the new value for the node by looking into the event map using the provided event path.
+    var currMap: ReadableMap? = event
+    var currArray: ReadableArray? = null
+    for (i in 0 until eventPath.size - 1) {
+      if (currMap != null) {
+        val key = eventPath[i]
+        val keyType = currMap.getType(key)
+        if (keyType == ReadableType.Map) {
+          currMap = currMap.getMap(key)
+          currArray = null
+        } else if (keyType == ReadableType.Array) {
+          currArray = currMap.getArray(key)
+          currMap = null
+        } else {
+          throw UnexpectedNativeTypeException("Unexpected type $keyType for key '$key'")
+        }
+      } else {
+        val index = eventPath[i].toInt()
+        val keyType = currArray?.getType(index)
+        if (keyType == ReadableType.Map) {
+          currMap = currArray?.getMap(index)
+          currArray = null
+        } else if (keyType == ReadableType.Array) {
+          currArray = currArray?.getArray(index)
+          currMap = null
+        } else {
+          throw UnexpectedNativeTypeException("Unexpected type $keyType for index '$index'")
+        }
+      }
+    }
+    val lastKey = eventPath[eventPath.size - 1]
+    if (currMap != null) {
+      valueNode.nodeValue = currMap.getDouble(lastKey)
+    } else {
+      val lastIndex = lastKey.toInt()
+      valueNode.nodeValue = currArray?.getDouble(lastIndex) ?: 0.0
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/FrameBasedAnimationDriver.kt

@@ -0,0 +1,104 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.animated
+
+import com.facebook.common.logging.FLog
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.build.ReactBuildConfig
+
+/**
+ * Implementation of [AnimationDriver] which provides a support for simple time-based animations
+ * that are pre-calculate on the JS side. For each animation frame JS provides a value from 0 to 1
+ * that indicates a progress of the animation at that frame.
+ */
+internal class FrameBasedAnimationDriver(config: ReadableMap) : AnimationDriver() {
+  private var startFrameTimeNanos: Long = -1
+  private var frames: DoubleArray = DoubleArray(0)
+  private var toValue = 0.0
+  private var fromValue = 0.0
+  private var iterations = 1
+  private var currentLoop = 1
+  private var logCount = 0
+
+  init {
+    resetConfig(config)
+  }
+
+  override fun resetConfig(config: ReadableMap) {
+    val framesConfig = config.getArray("frames")
+    if (framesConfig != null) {
+      val numberOfFrames = framesConfig.size()
+      if (frames.size != numberOfFrames) {
+        frames = DoubleArray(numberOfFrames) { i -> framesConfig.getDouble(i) }
+      }
+    }
+    toValue =
+        if (config.hasKey("toValue") && config.getType("toValue") == ReadableType.Number)
+            config.getDouble("toValue")
+        else 0.0
+    iterations =
+        if (config.hasKey("iterations") && config.getType("iterations") == ReadableType.Number)
+            config.getInt("iterations")
+        else 1
+    currentLoop = 1
+    hasFinished = iterations == 0
+    startFrameTimeNanos = -1
+  }
+
+  override fun runAnimationStep(frameTimeNanos: Long) {
+    val animatedValue = requireNotNull(animatedValue) { "Animated value should not be null" }
+    if (startFrameTimeNanos < 0) {
+      startFrameTimeNanos = frameTimeNanos
+      if (currentLoop == 1) {
+        // initiate start value when animation runs for the first time
+        fromValue = animatedValue.nodeValue
+      }
+    }
+    val timeFromStartMillis = (frameTimeNanos - startFrameTimeNanos) / 1000000
+    val frameIndex = Math.round(timeFromStartMillis / FRAME_TIME_MILLIS).toInt()
+    if (frameIndex < 0) {
+      val message =
+          ("Calculated frame index should never be lower than 0. Called with frameTimeNanos " +
+              frameTimeNanos +
+              " and mStartFrameTimeNanos " +
+              startFrameTimeNanos)
+      check(!ReactBuildConfig.DEBUG) { message }
+      if (logCount < 100) {
+        FLog.w(ReactConstants.TAG, message)
+        logCount++
+      }
+      return
+    } else if (hasFinished) {
+      // nothing to do here
+      return
+    }
+    val nextValue: Double
+    if (frameIndex >= frames.size - 1) {
+      if (iterations == -1 || currentLoop < iterations) {
+        // Use last frame value, just in case it's different from mToValue
+        nextValue = fromValue + frames[frames.size - 1] * (toValue - fromValue)
+        startFrameTimeNanos = -1
+        currentLoop++
+      } else {
+        // animation has completed, no more frames left
+        nextValue = toValue
+        hasFinished = true
+      }
+    } else {
+      nextValue = fromValue + frames[frameIndex] * (toValue - fromValue)
+    }
+    animatedValue.nodeValue = nextValue
+  }
+
+  companion object {
+    // 60FPS
+    private const val FRAME_TIME_MILLIS = 1000.0 / 60.0
+  }
+}