react-native-reanimated 4.0.1 → 4.0.2

package/Common/cpp/reanimated/Fabric/updates/UpdatesRegistryManager.cpp

@@ -57,25 +57,24 @@ void UpdatesRegistryManager::unmarkNodeAsRemovable(Tag viewTag) {
 
 void UpdatesRegistryManager::handleNodeRemovals(
     const RootShadowNode &rootShadowNode) {
-  for (auto it = removableShadowNodes_.begin();
-       it != removableShadowNodes_.end();) {
-    const auto &shadowNode = it->second;
-    const auto &family = shadowNode->getFamily();
-    const auto &ancestors = family.getAncestors(rootShadowNode);
-
-    // Skip if the node hasn't been removed
-    if (!ancestors.empty()) {
-      ++it;
+  RemovableShadowNodes remainingShadowNodes;
+
+  for (const auto &[tag, shadowNode] : removableShadowNodes_) {
+    if (!shadowNode) {
       continue;
     }
 
-    const auto tag = shadowNode->getTag();
-    for (auto &registry : registries_) {
-      registry->remove(tag);
+    if (shadowNode->getFamily().getAncestors(rootShadowNode).empty()) {
+      for (auto &registry : registries_) {
+        registry->remove(tag);
+      }
+      staticPropsRegistry_->remove(tag);
+    } else {
+      remainingShadowNodes.emplace(tag, shadowNode);
     }
-    staticPropsRegistry_->remove(tag);
-    it = removableShadowNodes_.erase(it);
   }
+
+  removableShadowNodes_ = std::move(remainingShadowNodes);
 }
 
 PropsMap UpdatesRegistryManager::collectProps() {

package/Common/cpp/reanimated/Fabric/updates/UpdatesRegistryManager.h

@@ -45,11 +45,13 @@ class UpdatesRegistryManager {
 #endif
 
  private:
+  using RemovableShadowNodes =
+      std::unordered_map<Tag, std::shared_ptr<const ShadowNode>>;
+
   mutable std::mutex mutex_;
   std::atomic<bool> isPaused_;
   std::atomic<bool> shouldCommitAfterPause_;
-  std::unordered_map<Tag, std::shared_ptr<const ShadowNode>>
-      removableShadowNodes_;
+  RemovableShadowNodes removableShadowNodes_;
   std::vector<std::shared_ptr<UpdatesRegistry>> registries_;
   const std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
 

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy.h

@@ -44,14 +44,14 @@ struct LayoutAnimationsProxy
   mutable std::unordered_map<Tag, int> leastRemoved;
   mutable std::vector<Tag> finishedAnimationTags_;
   std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
-  ContextContainer::Shared contextContainer_;
+  std::shared_ptr<const ContextContainer> contextContainer_;
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
   jsi::Runtime &uiRuntime_;
   const std::shared_ptr<UIScheduler> uiScheduler_;
   LayoutAnimationsProxy(
       std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager,
       SharedComponentDescriptorRegistry componentDescriptorRegistry,
-      ContextContainer::Shared contextContainer,
+      std::shared_ptr<const ContextContainer> contextContainer,
       jsi::Runtime &uiRuntime,
       const std::shared_ptr<UIScheduler> uiScheduler)
       : layoutAnimationsManager_(layoutAnimationsManager),

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp

@@ -408,6 +408,7 @@ void ReanimatedModuleProxy::setViewStyle(
 void ReanimatedModuleProxy::markNodeAsRemovable(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeWrapper) {
+  auto lock = updatesRegistryManager_->lock();
   auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
   updatesRegistryManager_->markNodeAsRemovable(shadowNode);
 }
@@ -415,6 +416,7 @@ void ReanimatedModuleProxy::markNodeAsRemovable(
 void ReanimatedModuleProxy::unmarkNodeAsRemovable(
     jsi::Runtime &rt,
     const jsi::Value &viewTag) {
+  auto lock = updatesRegistryManager_->lock();
   updatesRegistryManager_->unmarkNodeAsRemovable(viewTag.asNumber());
 }
 
@@ -674,12 +676,35 @@ void ReanimatedModuleProxy::performOperations() {
     if constexpr (StaticFeatureFlags::getFlag(
                       "ANDROID_SYNCHRONOUSLY_UPDATE_UI_PROPS")) {
       static const std::unordered_set<std::string> synchronousProps = {
-          "transform",
           "opacity",
-          "borderRadius",
+          "elevation",
+          "zIndex",
+          // "shadowOpacity", // not supported on Android
+          // "shadowRadius", // not supported on Android
           "backgroundColor",
-          "borderColor",
           // "color", // TODO: fix animating color of Animated.Text
+          "tintColor",
+          "borderRadius",
+          "borderTopLeftRadius",
+          "borderTopRightRadius",
+          "borderTopStartRadius",
+          "borderTopEndRadius",
+          "borderBottomLeftRadius",
+          "borderBottomRightRadius",
+          "borderBottomStartRadius",
+          "borderBottomEndRadius",
+          "borderStartStartRadius",
+          "borderStartEndRadius",
+          "borderEndStartRadius",
+          "borderEndEndRadius",
+          "borderColor",
+          "borderTopColor",
+          "borderBottomColor",
+          "borderLeftColor",
+          "borderRightColor",
+          "borderStartColor",
+          "borderEndColor",
+          "transform",
       };
 
       // NOTE: Keep in sync with NativeProxy.java
@@ -687,11 +712,38 @@ void ReanimatedModuleProxy::performOperations() {
       static constexpr auto CMD_START_OF_TRANSFORM = 2;
       static constexpr auto CMD_END_OF_TRANSFORM = 3;
       static constexpr auto CMD_END_OF_VIEW = 4;
+
       static constexpr auto CMD_OPACITY = 10;
-      static constexpr auto CMD_BORDER_RADIUS = 11;
-      static constexpr auto CMD_BACKGROUND_COLOR = 12;
-      static constexpr auto CMD_BORDER_COLOR = 13;
-      static constexpr auto CMD_COLOR = 14;
+      static constexpr auto CMD_ELEVATION = 11;
+      static constexpr auto CMD_Z_INDEX = 12;
+      static constexpr auto CMD_SHADOW_OPACITY = 13;
+      static constexpr auto CMD_SHADOW_RADIUS = 14;
+      static constexpr auto CMD_BACKGROUND_COLOR = 15;
+      static constexpr auto CMD_COLOR = 16;
+      static constexpr auto CMD_TINT_COLOR = 17;
+
+      static constexpr auto CMD_BORDER_RADIUS = 20;
+      static constexpr auto CMD_BORDER_TOP_LEFT_RADIUS = 21;
+      static constexpr auto CMD_BORDER_TOP_RIGHT_RADIUS = 22;
+      static constexpr auto CMD_BORDER_TOP_START_RADIUS = 23;
+      static constexpr auto CMD_BORDER_TOP_END_RADIUS = 24;
+      static constexpr auto CMD_BORDER_BOTTOM_LEFT_RADIUS = 25;
+      static constexpr auto CMD_BORDER_BOTTOM_RIGHT_RADIUS = 26;
+      static constexpr auto CMD_BORDER_BOTTOM_START_RADIUS = 27;
+      static constexpr auto CMD_BORDER_BOTTOM_END_RADIUS = 28;
+      static constexpr auto CMD_BORDER_START_START_RADIUS = 29;
+      static constexpr auto CMD_BORDER_START_END_RADIUS = 30;
+      static constexpr auto CMD_BORDER_END_START_RADIUS = 31;
+      static constexpr auto CMD_BORDER_END_END_RADIUS = 32;
+
+      static constexpr auto CMD_BORDER_COLOR = 40;
+      static constexpr auto CMD_BORDER_TOP_COLOR = 41;
+      static constexpr auto CMD_BORDER_BOTTOM_COLOR = 42;
+      static constexpr auto CMD_BORDER_LEFT_COLOR = 43;
+      static constexpr auto CMD_BORDER_RIGHT_COLOR = 44;
+      static constexpr auto CMD_BORDER_START_COLOR = 45;
+      static constexpr auto CMD_BORDER_END_COLOR = 46;
+
       static constexpr auto CMD_TRANSFORM_TRANSLATE_X = 100;
       static constexpr auto CMD_TRANSFORM_TRANSLATE_Y = 101;
       static constexpr auto CMD_TRANSFORM_SCALE = 102;
@@ -705,6 +757,7 @@ void ReanimatedModuleProxy::performOperations() {
       static constexpr auto CMD_TRANSFORM_SKEW_Y = 110;
       static constexpr auto CMD_TRANSFORM_MATRIX = 111;
       static constexpr auto CMD_TRANSFORM_PERSPECTIVE = 112;
+
       static constexpr auto CMD_UNIT_DEG = 200;
       static constexpr auto CMD_UNIT_RAD = 201;
       static constexpr auto CMD_UNIT_PX = 202;
@@ -713,47 +766,135 @@ void ReanimatedModuleProxy::performOperations() {
       const auto propNameToCommand = [](const std::string &name) {
         if (name == "opacity")
           return CMD_OPACITY;
-        if (name == "borderRadius")
-          return CMD_BORDER_RADIUS;
+
+        if (name == "elevation")
+          return CMD_ELEVATION;
+
+        if (name == "zIndex")
+          return CMD_Z_INDEX;
+
+        if (name == "shadowOpacity")
+          return CMD_SHADOW_OPACITY;
+
+        if (name == "shadowRadius")
+          return CMD_SHADOW_RADIUS;
+
         if (name == "backgroundColor")
           return CMD_BACKGROUND_COLOR;
-        if (name == "borderColor")
-          return CMD_BORDER_COLOR;
+
         if (name == "color")
           return CMD_COLOR;
+
+        if (name == "tintColor")
+          return CMD_TINT_COLOR;
+
+        if (name == "borderRadius")
+          return CMD_BORDER_RADIUS;
+
+        if (name == "borderTopLeftRadius")
+          return CMD_BORDER_TOP_LEFT_RADIUS;
+
+        if (name == "borderTopRightRadius")
+          return CMD_BORDER_TOP_RIGHT_RADIUS;
+
+        if (name == "borderTopStartRadius")
+          return CMD_BORDER_TOP_START_RADIUS;
+
+        if (name == "borderTopEndRadius")
+          return CMD_BORDER_TOP_END_RADIUS;
+
+        if (name == "borderBottomLeftRadius")
+          return CMD_BORDER_BOTTOM_LEFT_RADIUS;
+
+        if (name == "borderBottomRightRadius")
+          return CMD_BORDER_BOTTOM_RIGHT_RADIUS;
+
+        if (name == "borderBottomStartRadius")
+          return CMD_BORDER_BOTTOM_START_RADIUS;
+
+        if (name == "borderBottomEndRadius")
+          return CMD_BORDER_BOTTOM_END_RADIUS;
+
+        if (name == "borderStartStartRadius")
+          return CMD_BORDER_START_START_RADIUS;
+
+        if (name == "borderStartEndRadius")
+          return CMD_BORDER_START_END_RADIUS;
+
+        if (name == "borderEndStartRadius")
+          return CMD_BORDER_END_START_RADIUS;
+
+        if (name == "borderEndEndRadius")
+          return CMD_BORDER_END_END_RADIUS;
+
+        if (name == "borderColor")
+          return CMD_BORDER_COLOR;
+
+        if (name == "borderTopColor")
+          return CMD_BORDER_TOP_COLOR;
+
+        if (name == "borderBottomColor")
+          return CMD_BORDER_BOTTOM_COLOR;
+
+        if (name == "borderLeftColor")
+          return CMD_BORDER_LEFT_COLOR;
+
+        if (name == "borderRightColor")
+          return CMD_BORDER_RIGHT_COLOR;
+
+        if (name == "borderStartColor")
+          return CMD_BORDER_START_COLOR;
+
+        if (name == "borderEndColor")
+          return CMD_BORDER_END_COLOR;
+
         if (name == "transform")
           return CMD_START_OF_TRANSFORM; // TODO: use CMD_TRANSFORM?
-        throw std::runtime_error("Unsupported style: " + name);
+
+        throw std::runtime_error("[Reanimated] Unsupported style: " + name);
       };
 
       const auto transformNameToCommand = [](const std::string &name) {
         if (name == "translateX")
           return CMD_TRANSFORM_TRANSLATE_X;
+
         if (name == "translateY")
           return CMD_TRANSFORM_TRANSLATE_Y;
+
         if (name == "scale")
           return CMD_TRANSFORM_SCALE;
+
         if (name == "scaleX")
           return CMD_TRANSFORM_SCALE_X;
+
         if (name == "scaleY")
           return CMD_TRANSFORM_SCALE_Y;
+
         if (name == "rotate")
           return CMD_TRANSFORM_ROTATE;
+
         if (name == "rotateX")
           return CMD_TRANSFORM_ROTATE_X;
+
         if (name == "rotateY")
           return CMD_TRANSFORM_ROTATE_Y;
+
         if (name == "rotateZ")
           return CMD_TRANSFORM_ROTATE_Z;
+
         if (name == "skewX")
           return CMD_TRANSFORM_SKEW_X;
+
         if (name == "skewY")
           return CMD_TRANSFORM_SKEW_Y;
+
         if (name == "matrix")
           return CMD_TRANSFORM_MATRIX;
+
         if (name == "perspective")
           return CMD_TRANSFORM_PERSPECTIVE;
-        throw std::runtime_error("Unsupported transform: " + name);
+
+        throw std::runtime_error("[Reanimated] Unsupported transform: " + name);
       };
 
       UpdatesBatch synchronousUpdatesBatch, shadowTreeUpdatesBatch;
@@ -787,29 +928,71 @@ void ReanimatedModuleProxy::performOperations() {
             const auto command = propNameToCommand(key.getString());
             switch (command) {
               case CMD_OPACITY:
-              case CMD_BORDER_RADIUS:
+              case CMD_ELEVATION:
+              case CMD_Z_INDEX:
+              case CMD_SHADOW_OPACITY:
+              case CMD_SHADOW_RADIUS:
                 intBuffer.push_back(command);
                 doubleBuffer.push_back(value.asDouble());
                 break;
 
               case CMD_BACKGROUND_COLOR:
-              case CMD_BORDER_COLOR:
               case CMD_COLOR:
+              case CMD_TINT_COLOR:
+              case CMD_BORDER_COLOR:
+              case CMD_BORDER_TOP_COLOR:
+              case CMD_BORDER_BOTTOM_COLOR:
+              case CMD_BORDER_LEFT_COLOR:
+              case CMD_BORDER_RIGHT_COLOR:
+              case CMD_BORDER_START_COLOR:
+              case CMD_BORDER_END_COLOR:
                 intBuffer.push_back(command);
                 intBuffer.push_back(value.asInt());
                 break;
 
+              case CMD_BORDER_RADIUS:
+              case CMD_BORDER_TOP_LEFT_RADIUS:
+              case CMD_BORDER_TOP_RIGHT_RADIUS:
+              case CMD_BORDER_TOP_START_RADIUS:
+              case CMD_BORDER_TOP_END_RADIUS:
+              case CMD_BORDER_BOTTOM_LEFT_RADIUS:
+              case CMD_BORDER_BOTTOM_RIGHT_RADIUS:
+              case CMD_BORDER_BOTTOM_START_RADIUS:
+              case CMD_BORDER_BOTTOM_END_RADIUS:
+              case CMD_BORDER_START_START_RADIUS:
+              case CMD_BORDER_START_END_RADIUS:
+              case CMD_BORDER_END_START_RADIUS:
+              case CMD_BORDER_END_END_RADIUS:
+                intBuffer.push_back(command);
+                if (value.isDouble()) {
+                  intBuffer.push_back(CMD_UNIT_PX);
+                  doubleBuffer.push_back(value.getDouble());
+                } else if (value.isString()) {
+                  const auto &valueStr = value.getString();
+                  if (!valueStr.ends_with("%")) {
+                    throw std::runtime_error(
+                        "[Reanimated] Border radius string must be a percentage");
+                  }
+                  intBuffer.push_back(CMD_UNIT_PERCENT);
+                  doubleBuffer.push_back(std::stof(valueStr.substr(0, -1)));
+                } else {
+                  throw std::runtime_error(
+                      "[Reanimated] Border radius value must be either a number or a string");
+                }
+                break;
+
               case CMD_START_OF_TRANSFORM:
                 intBuffer.push_back(command);
                 react_native_assert(
-                    value.isArray() && "Transform value must be an array");
+                    value.isArray() &&
+                    "[Reanimated] Transform value must be an array");
                 for (const auto &item : value) {
                   react_native_assert(
                       item.isObject() &&
-                      "Transform array item must be an object");
+                      "[Reanimated] Transform array item must be an object");
                   react_native_assert(
                       item.size() == 1 &&
-                      "Transform array item must have exactly one key-value pair");
+                      "[Reanimated] Transform array item must have exactly one key-value pair");
                   const auto transformCommand =
                       transformNameToCommand(item.keys().begin()->getString());
                   const auto &transformValue = *item.values().begin();
@@ -828,20 +1011,20 @@ void ReanimatedModuleProxy::performOperations() {
                       intBuffer.push_back(transformCommand);
                       if (transformValue.isDouble()) {
                         intBuffer.push_back(CMD_UNIT_PX);
-                        doubleBuffer.push_back(transformValue.asDouble());
+                        doubleBuffer.push_back(transformValue.getDouble());
                       } else if (transformValue.isString()) {
                         const auto &transformValueStr =
                             transformValue.getString();
                         if (!transformValueStr.ends_with("%")) {
                           throw std::runtime_error(
-                              "String translate must be a percentage");
+                              "[Reanimated] String translate must be a percentage");
                         }
                         intBuffer.push_back(CMD_UNIT_PERCENT);
                         doubleBuffer.push_back(
                             std::stof(transformValueStr.substr(0, -1)));
                       } else {
                         throw std::runtime_error(
-                            "Translate value must be a number or a string");
+                            "[Reanimated] Translate value must be either a number or a string");
                       }
                       break;
                     }
@@ -861,7 +1044,8 @@ void ReanimatedModuleProxy::performOperations() {
                         intBuffer.push_back(CMD_UNIT_RAD);
                       } else {
                         throw std::runtime_error(
-                            "Unsupported rotation unit: " + transformValueStr);
+                            "[Reanimated] Unsupported rotation unit: " +
+                            transformValueStr);
                       }
                       doubleBuffer.push_back(
                           std::stof(transformValueStr.substr(0, -3)));
@@ -872,7 +1056,7 @@ void ReanimatedModuleProxy::performOperations() {
                       intBuffer.push_back(transformCommand);
                       react_native_assert(
                           transformValue.isArray() &&
-                          "Matrix must be an array");
+                          "[Reanimated] Matrix must be an array");
                       int size = transformValue.size();
                       intBuffer.push_back(size);
                       for (int i = 0; i < size; i++) {

package/android/build.gradle

@@ -85,18 +85,6 @@ def toPlatformFileString(String path) {
   return path
 }
 
-def validateWorkletsVersion() {
-    def result = providers.exec {
-        workingDir(projectDir.path)
-        commandLine("node", "./../scripts/validate-worklets-build.js")
-        ignoreExitValue = true
-    }
-
-    if (result.getResult().get().exitValue != 0) {
-        throw new GradleException(result.getStandardError().getAsText().get().trim())
-    }
-}
-
 def getReanimatedStaticFeatureFlags() {
     def featureFlags = new HashMap<String, String>()
 
@@ -123,6 +111,7 @@ if (isNewArchitectureEnabled()) {
     apply plugin: "com.facebook.react"
 }
 
+def packageDir = project.projectDir.parentFile
 def reactNativeRootDir = resolveReactNativeDirectory()
 def reactNativeWorkletsRootDir = resolveReactNativeWorkletsDirectory()
 def REACT_NATIVE_MINOR_VERSION = getReactNativeMinorVersion()
@@ -270,7 +259,6 @@ android {
                 if (!IS_REANIMATED_EXAMPLE_APP) {
                     return
                 }
-                def packageDir = new File("${project.projectDir}/..")
 
                 def generated = new File("${compileTask.abi.getCxxBuildFolder()}/compile_commands.json")
                 def output = new File("${packageDir}/compile_commands.json")
@@ -284,7 +272,7 @@ android {
 
 task assertMinimalReactNativeVersionTask {
     // If you change the minimal React Native version remember to update Compatibility Table in docs
-    def minimalReactNativeVersion = 75
+    def minimalReactNativeVersion = 78
     onlyIf { REACT_NATIVE_MINOR_VERSION < minimalReactNativeVersion }
     doFirst {
         throw new GradleException("[Reanimated] Unsupported React Native version. Please use React Native 0.$minimalReactNativeVersion or newer.")
@@ -302,9 +290,17 @@ task assertNewArchitectureEnabledTask {
 
 preBuild.dependsOn(assertNewArchitectureEnabledTask)
 
+def validateWorkletsBuildResult = providers.exec {
+    workingDir(projectDir.path)
+    commandLine("node", "./../scripts/validate-worklets-build.js")
+    ignoreExitValue = true
+}
+
 task assertWorkletsVersionTask {
     doFirst {
-        validateWorkletsVersion()
+        if (validateWorkletsBuildResult.getResult().get().exitValue != 0) {
+            throw new GradleException(validateWorkletsBuildResult.getStandardError().getAsText().get().trim())
+        }
     }
 }
 

package/android/src/main/java/com/swmansion/reanimated/NativeProxy.java

@@ -185,11 +185,38 @@ public class NativeProxy {
   private static final int CMD_START_OF_TRANSFORM = 2;
   private static final int CMD_END_OF_TRANSFORM = 3;
   private static final int CMD_END_OF_VIEW = 4;
+
   private static final int CMD_OPACITY = 10;
-  private static final int CMD_BORDER_RADIUS = 11;
-  private static final int CMD_BACKGROUND_COLOR = 12;
-  private static final int CMD_BORDER_COLOR = 13;
-  private static final int CMD_COLOR = 14;
+  private static final int CMD_ELEVATION = 11;
+  private static final int CMD_Z_INDEX = 12;
+  private static final int CMD_SHADOW_OPACITY = 13;
+  private static final int CMD_SHADOW_RADIUS = 14;
+  private static final int CMD_BACKGROUND_COLOR = 15;
+  private static final int CMD_COLOR = 16;
+  private static final int CMD_TINT_COLOR = 17;
+
+  private static final int CMD_BORDER_RADIUS = 20;
+  private static final int CMD_BORDER_TOP_LEFT_RADIUS = 21;
+  private static final int CMD_BORDER_TOP_RIGHT_RADIUS = 22;
+  private static final int CMD_BORDER_TOP_START_RADIUS = 23;
+  private static final int CMD_BORDER_TOP_END_RADIUS = 24;
+  private static final int CMD_BORDER_BOTTOM_LEFT_RADIUS = 25;
+  private static final int CMD_BORDER_BOTTOM_RIGHT_RADIUS = 26;
+  private static final int CMD_BORDER_BOTTOM_START_RADIUS = 27;
+  private static final int CMD_BORDER_BOTTOM_END_RADIUS = 28;
+  private static final int CMD_BORDER_START_START_RADIUS = 29;
+  private static final int CMD_BORDER_START_END_RADIUS = 30;
+  private static final int CMD_BORDER_END_START_RADIUS = 31;
+  private static final int CMD_BORDER_END_END_RADIUS = 32;
+
+  private static final int CMD_BORDER_COLOR = 40;
+  private static final int CMD_BORDER_TOP_COLOR = 41;
+  private static final int CMD_BORDER_BOTTOM_COLOR = 42;
+  private static final int CMD_BORDER_LEFT_COLOR = 43;
+  private static final int CMD_BORDER_RIGHT_COLOR = 44;
+  private static final int CMD_BORDER_START_COLOR = 45;
+  private static final int CMD_BORDER_END_COLOR = 46;
+
   private static final int CMD_TRANSFORM_TRANSLATE_X = 100;
   private static final int CMD_TRANSFORM_TRANSLATE_Y = 101;
   private static final int CMD_TRANSFORM_SCALE = 102;
@@ -203,6 +230,7 @@ public class NativeProxy {
   private static final int CMD_TRANSFORM_SKEW_Y = 110;
   private static final int CMD_TRANSFORM_MATRIX = 111;
   private static final int CMD_TRANSFORM_PERSPECTIVE = 112;
+
   private static final int CMD_UNIT_DEG = 200;
   private static final int CMD_UNIT_RAD = 201;
   private static final int CMD_UNIT_PX = 202;
@@ -211,10 +239,33 @@ public class NativeProxy {
   private static String commandToString(int command) {
     return switch (command) {
       case CMD_OPACITY -> "opacity";
-      case CMD_BORDER_RADIUS -> "borderRadius";
+      case CMD_ELEVATION -> "elevation";
+      case CMD_Z_INDEX -> "zIndex";
+      case CMD_SHADOW_OPACITY -> "shadowOpacity";
+      case CMD_SHADOW_RADIUS -> "shadowRadius";
       case CMD_BACKGROUND_COLOR -> "backgroundColor";
-      case CMD_BORDER_COLOR -> "borderColor";
       case CMD_COLOR -> "color";
+      case CMD_TINT_COLOR -> "tintColor";
+      case CMD_BORDER_RADIUS -> "borderRadius";
+      case CMD_BORDER_TOP_LEFT_RADIUS -> "borderTopLeftRadius";
+      case CMD_BORDER_TOP_RIGHT_RADIUS -> "borderTopRightRadius";
+      case CMD_BORDER_TOP_START_RADIUS -> "borderTopStartRadius";
+      case CMD_BORDER_TOP_END_RADIUS -> "borderTopEndRadius";
+      case CMD_BORDER_BOTTOM_LEFT_RADIUS -> "borderBottomLeftRadius";
+      case CMD_BORDER_BOTTOM_RIGHT_RADIUS -> "borderBottomRightRadius";
+      case CMD_BORDER_BOTTOM_START_RADIUS -> "borderBottomStartRadius";
+      case CMD_BORDER_BOTTOM_END_RADIUS -> "borderBottomEndRadius";
+      case CMD_BORDER_START_START_RADIUS -> "borderStartStartRadius";
+      case CMD_BORDER_START_END_RADIUS -> "borderStartEndRadius";
+      case CMD_BORDER_END_START_RADIUS -> "borderEndStartRadius";
+      case CMD_BORDER_END_END_RADIUS -> "borderEndEndRadius";
+      case CMD_BORDER_COLOR -> "borderColor";
+      case CMD_BORDER_TOP_COLOR -> "borderTopColor";
+      case CMD_BORDER_BOTTOM_COLOR -> "borderBottomColor";
+      case CMD_BORDER_LEFT_COLOR -> "borderLeftColor";
+      case CMD_BORDER_RIGHT_COLOR -> "borderRightColor";
+      case CMD_BORDER_START_COLOR -> "borderStartColor";
+      case CMD_BORDER_END_COLOR -> "borderEndColor";
       default -> throw new RuntimeException("Unknown command: " + command);
     };
   }
@@ -253,7 +304,10 @@ public class NativeProxy {
           break;
 
         case CMD_OPACITY:
-        case CMD_BORDER_RADIUS:
+        case CMD_ELEVATION:
+        case CMD_Z_INDEX:
+        case CMD_SHADOW_OPACITY:
+        case CMD_SHADOW_RADIUS:
           {
             String name = commandToString(command);
             props.putDouble(name, doubleIterator.nextDouble());
@@ -261,14 +315,45 @@ public class NativeProxy {
           }
 
         case CMD_BACKGROUND_COLOR:
-        case CMD_BORDER_COLOR:
         case CMD_COLOR:
+        case CMD_TINT_COLOR:
+        case CMD_BORDER_COLOR:
+        case CMD_BORDER_TOP_COLOR:
+        case CMD_BORDER_BOTTOM_COLOR:
+        case CMD_BORDER_LEFT_COLOR:
+        case CMD_BORDER_RIGHT_COLOR:
+        case CMD_BORDER_START_COLOR:
+        case CMD_BORDER_END_COLOR:
           {
             String name = commandToString(command);
             props.putInt(name, intIterator.nextInt());
             break;
           }
 
+        case CMD_BORDER_RADIUS:
+        case CMD_BORDER_TOP_LEFT_RADIUS:
+        case CMD_BORDER_TOP_RIGHT_RADIUS:
+        case CMD_BORDER_TOP_START_RADIUS:
+        case CMD_BORDER_TOP_END_RADIUS:
+        case CMD_BORDER_BOTTOM_LEFT_RADIUS:
+        case CMD_BORDER_BOTTOM_RIGHT_RADIUS:
+        case CMD_BORDER_BOTTOM_START_RADIUS:
+        case CMD_BORDER_BOTTOM_END_RADIUS:
+        case CMD_BORDER_START_START_RADIUS:
+        case CMD_BORDER_START_END_RADIUS:
+        case CMD_BORDER_END_START_RADIUS:
+        case CMD_BORDER_END_END_RADIUS:
+          {
+            String name = commandToString(command);
+            double value = doubleIterator.nextDouble();
+            switch (intIterator.nextInt()) {
+              case CMD_UNIT_PX -> props.putDouble(name, value);
+              case CMD_UNIT_PERCENT -> props.putString(name, value + "%");
+              default -> throw new RuntimeException("Unknown unit command");
+            }
+            break;
+          }
+
         case CMD_START_OF_TRANSFORM:
           JavaOnlyArray transform = new JavaOnlyArray();
           while (true) {

package/lib/module/animation/spring/springUtils.js

@@ -262,7 +262,9 @@ export function isAnimationTerminatingCalculation(animation, config) {
     initialEnergy
   } = animation;
   if (config.overshootClamping) {
-    if (current > toValue && startValue < toValue || current < toValue && startValue > toValue) {
+    const leftBound = startValue >= 0 ? toValue : toValue + startValue;
+    const rightBound = leftBound + Math.abs(startValue);
+    if (current < leftBound || current > rightBound) {
       return true;
     }
   }