react-native-reanimated 4.0.0 → 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/RNReanimated.podspec

@@ -46,12 +46,6 @@ Pod::Spec.new do |s|
       sss.header_dir = "reanimated"
       sss.header_mappings_dir = "apple/reanimated"
     end
-
-    ss.subspec "view" do |sss|
-      sss.source_files = "Common/NativeView/**/*.{mm,h,cpp}"
-      sss.header_dir = ""
-      sss.header_mappings_dir = "Common/NativeView"
-    end
   end
 
   s.pod_target_xcconfig = {

package/android/CMakeLists.txt

@@ -49,7 +49,6 @@ file(GLOB_RECURSE REANIMATED_ANDROID_CPP_SOURCES CONFIGURE_DEPENDS
 
 find_package(fbjni REQUIRED CONFIG)
 find_package(ReactAndroid REQUIRED CONFIG)
-find_package(react-native-worklets REQUIRED CONFIG)
 
 add_library(reanimated SHARED ${REANIMATED_COMMON_CPP_SOURCES}
                               ${REANIMATED_ANDROID_CPP_SOURCES})
@@ -65,13 +64,30 @@ target_include_directories(
           "${REACT_NATIVE_DIR}/ReactCommon/runtimeexecutor"
           "${REACT_NATIVE_DIR}/ReactCommon/jsiexecutor"
           "${REACT_NATIVE_DIR}/ReactCommon/react/renderer/graphics/platform/cxx"
-)
+          "${REACT_NATIVE_WORKLETS_DIR}/Common/cpp"
+          "${REACT_NATIVE_WORKLETS_DIR}/android/src/main/cpp")
 
 set_target_properties(reanimated PROPERTIES LINKER_LANGUAGE CXX)
 
-target_link_libraries(reanimated log ReactAndroid::jsi fbjni::fbjni android)
+if(${CMAKE_BUILD_TYPE} MATCHES "Debug")
+  set(BUILD_TYPE "debug")
+else()
+  set(BUILD_TYPE "release")
+endif()
+
+add_library(worklets SHARED IMPORTED)
+
+set_target_properties(
+  worklets
+  PROPERTIES
+    IMPORTED_LOCATION
+    "${REACT_NATIVE_WORKLETS_DIR}/android/build/intermediates/cmake/${BUILD_TYPE}/obj/${ANDROID_ABI}/libworklets.so"
+)
+
+set_target_properties(reanimated PROPERTIES LINKER_LANGUAGE CXX)
 
-target_link_libraries(reanimated react-native-worklets::worklets)
+target_link_libraries(reanimated log ReactAndroid::jsi fbjni::fbjni android
+                      worklets)
 
 if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
   target_link_libraries(reanimated ReactAndroid::reactnative)

package/android/build.gradle

@@ -42,6 +42,28 @@ def resolveReactNativeDirectory() {
     )
 }
 
+def resolveReactNativeWorkletsDirectory() {
+    def reactNativeWorkletsLocation = safeAppExtGet("REACT_NATIVE_WORKLETS_NODE_MODULES_DIR", null)
+    if (reactNativeWorkletsLocation != null) {
+        return file(reactNativeWorkletsLocation)
+    }
+
+    // Fallback to node resolver for custom directory structures like monorepos.
+    def reactNativeWorkletsPackage = file(
+        providers.exec {
+            workingDir(rootDir)
+            commandLine("node", "--print", "require.resolve('react-native-worklets/package.json')")
+        }.standardOutput.asText.get().trim()
+    )
+    if (reactNativeWorkletsPackage.exists()) {
+        return reactNativeWorkletsPackage.parentFile
+    }
+
+    throw new GradleException(
+        "[Reanimated] Unable to resolve react-native-worklets location in node_modules. You should set project extension property (in `app/build.gradle`) named `REACT_NATIVE_WORKLETS_NODE_MODULES_DIR` with the path to react-native-worklets in node_modules."
+    )
+}
+
 def getReactNativeMinorVersion() {
     def reactNativeRootDir = resolveReactNativeDirectory()
     def reactProperties = new Properties()
@@ -63,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>()
 
@@ -101,7 +111,9 @@ if (isNewArchitectureEnabled()) {
     apply plugin: "com.facebook.react"
 }
 
+def packageDir = project.projectDir.parentFile
 def reactNativeRootDir = resolveReactNativeDirectory()
+def reactNativeWorkletsRootDir = resolveReactNativeWorkletsDirectory()
 def REACT_NATIVE_MINOR_VERSION = getReactNativeMinorVersion()
 def REANIMATED_VERSION = getReanimatedVersion()
 def IS_NEW_ARCHITECTURE_ENABLED = isNewArchitectureEnabled()
@@ -181,6 +193,7 @@ android {
                         "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                         "-DANDROID_TOOLCHAIN=clang",
                         "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
+                        "-DREACT_NATIVE_WORKLETS_DIR=${toPlatformFileString(reactNativeWorkletsRootDir.path)}",
                         "-DIS_REANIMATED_EXAMPLE_APP=${IS_REANIMATED_EXAMPLE_APP}",
                         "-DREANIMATED_PROFILING=${REANIMATED_PROFILING}",
                         "-DREANIMATED_VERSION=${REANIMATED_VERSION}",
@@ -246,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")
@@ -260,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.")
@@ -278,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())
+        }
     }
 }
 
@@ -324,3 +344,12 @@ dependencies {
 }
 
 preBuild.dependsOn(prepareReanimatedHeadersForPrefabs)
+
+if (project != rootProject) {
+    evaluationDependsOn(":react-native-worklets")
+
+    afterEvaluate {
+        tasks.getByName("externalNativeBuildDebug").dependsOn(findProject(":react-native-worklets").tasks.getByName("externalNativeBuildDebug"))
+        tasks.getByName("externalNativeBuildRelease").dependsOn(findProject(":react-native-worklets").tasks.getByName("externalNativeBuildRelease"))
+    }
+}