react-native-reanimated 4.0.1 → 4.0.3

package/Common/cpp/reanimated/CSS/interpolation/groups/ArrayPropertiesInterpolator.cpp

@@ -45,14 +45,19 @@ void ArrayPropertiesInterpolator::updateKeyframesFromStyleChange(
     const folly::dynamic &oldStyleValue,
     const folly::dynamic &newStyleValue,
     const folly::dynamic &lastUpdateValue) {
-  const folly::dynamic empty = folly::dynamic::array();
-  const auto oldStyleArray = !oldStyleValue.empty() ? oldStyleValue : empty;
-  const auto newStyleArray = !newStyleValue.empty() ? newStyleValue : empty;
-  const auto lastUpdateArray =
-      !lastUpdateValue.empty() ? lastUpdateValue : empty;
+  const auto emptyArray = folly::dynamic::array();
+  const auto null = folly::dynamic();
+
+  const auto &oldStyleArray =
+      oldStyleValue.empty() ? emptyArray : oldStyleValue;
+  const auto &newStyleArray =
+      newStyleValue.empty() ? emptyArray : newStyleValue;
+  const auto &lastUpdateArray =
+      lastUpdateValue.empty() ? emptyArray : lastUpdateValue;
 
   const size_t oldSize = oldStyleArray.size();
   const size_t newSize = newStyleArray.size();
+  const size_t lastSize = lastUpdateArray.size();
   const size_t valuesCount = std::max(oldSize, newSize);
 
   resizeInterpolators(valuesCount);
@@ -61,9 +66,9 @@ void ArrayPropertiesInterpolator::updateKeyframesFromStyleChange(
     // These index checks ensure that interpolation works between 2 arrays
     // with different lengths
     interpolators_[i]->updateKeyframesFromStyleChange(
-        i < oldSize ? oldStyleArray[i] : empty,
-        i < newSize ? newStyleArray[i] : empty,
-        i < valuesCount ? lastUpdateArray[i] : empty);
+        i < oldSize ? oldStyleArray[i] : null,
+        i < newSize ? newStyleArray[i] : null,
+        i < lastSize ? lastUpdateArray[i] : null);
   }
 }
 

package/Common/cpp/reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.cpp

@@ -37,14 +37,16 @@ void RecordPropertiesInterpolator::updateKeyframesFromStyleChange(
     const folly::dynamic &newStyleValue,
     const folly::dynamic &lastUpdateValue) {
   // TODO - maybe add a possibility to remove interpolators that are no longer
-  // used  (for now, for simplicity, we only add new ones)
-  const folly::dynamic empty = folly::dynamic::object();
-  const folly::dynamic &oldStyleObject =
-      !oldStyleValue.empty() ? oldStyleValue : empty;
-  const folly::dynamic &newStyleObject =
-      !newStyleValue.empty() ? newStyleValue : empty;
-  const folly::dynamic &lastUpdateObject =
-      !lastUpdateValue.empty() ? lastUpdateValue : empty;
+  // used (for now, for simplicity, we only add new ones)
+  const folly::dynamic emptyObject = folly::dynamic::object();
+  const auto null = folly::dynamic();
+
+  const auto &oldStyleObject =
+      oldStyleValue.empty() ? emptyObject : oldStyleValue;
+  const auto &newStyleObject =
+      newStyleValue.empty() ? emptyObject : newStyleValue;
+  const auto &lastUpdateObject =
+      lastUpdateValue.empty() ? emptyObject : lastUpdateValue;
 
   std::unordered_set<std::string> propertyNamesSet;
   for (const auto &key : oldStyleObject.keys()) {
@@ -57,9 +59,9 @@ void RecordPropertiesInterpolator::updateKeyframesFromStyleChange(
   for (const auto &propertyName : propertyNamesSet) {
     maybeCreateInterpolator(propertyName);
     interpolators_[propertyName]->updateKeyframesFromStyleChange(
-        oldStyleObject.getDefault(propertyName, empty),
-        newStyleObject.getDefault(propertyName, empty),
-        lastUpdateObject.getDefault(propertyName, empty));
+        oldStyleObject.getDefault(propertyName, null),
+        newStyleObject.getDefault(propertyName, null),
+        lastUpdateObject.getDefault(propertyName, null));
   }
 }
 

package/Common/cpp/reanimated/CSS/interpolation/styles/TransitionStyleInterpolator.cpp

@@ -87,9 +87,10 @@ void TransitionStyleInterpolator::updateInterpolatedProperties(
     const auto &newValue = newPropsObj.getDefault(propertyName, empty);
     // Pass lastValue only if the interpolator is updated (no new interpolator
     // was created), otherwise pass an empty value
-    const auto &lastValue = !shouldCreateInterpolator
-        ? lastUpdateValue.getDefault(propertyName, empty)
-        : empty;
+    const auto &lastValue =
+        (shouldCreateInterpolator || lastUpdateValue.empty())
+        ? empty
+        : lastUpdateValue.getDefault(propertyName, empty);
 
     it->second->updateKeyframesFromStyleChange(oldValue, newValue, lastValue);
   }

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())
+        }
     }
 }