react-native-reanimated 3.0.0-rc.0 → 3.0.0-rc.1

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.cpp

@@ -35,10 +35,10 @@ jsi::Value AnimatedSensorModule::registerSensor(
     setter = [&, mutableObject](double newValues[]) {
       jsi::Runtime &runtime = *runtimeManager_->runtime.get();
       jsi::Object value(runtime);
-      value.setProperty(runtime, "qw", newValues[0]);
-      value.setProperty(runtime, "qx", newValues[1]);
-      value.setProperty(runtime, "qy", newValues[2]);
-      value.setProperty(runtime, "qz", newValues[3]);
+      value.setProperty(runtime, "qx", newValues[0]);
+      value.setProperty(runtime, "qy", newValues[1]);
+      value.setProperty(runtime, "qz", newValues[2]);
+      value.setProperty(runtime, "qw", newValues[3]);
       value.setProperty(runtime, "yaw", newValues[4]);
       value.setProperty(runtime, "pitch", newValues[5]);
       value.setProperty(runtime, "roll", newValues[6]);

package/Common/cpp/Fabric/FabricUtils.cpp

@@ -1,5 +1,10 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
+#if RNVERSION < 69
+#error \
+    "Reanimated 3 does not support React Native 0.68.x when Fabric is enabled. Please upgrade to React Native 0.69.0 or newer if you want to use Reanimated with the new architecture."
+#endif
+
 #include "FabricUtils.h"
 
 #include <react/renderer/uimanager/UIManagerBinding.h>
@@ -84,10 +89,10 @@ LayoutMetrics UIManager_getRelativeLayoutMetrics(
       shadowNode.getFamily(), *layoutableAncestorShadowNode, policy);
 }
 
-SharedShadowNode UIManager_cloneNode(
+ShadowNode::Shared UIManager_cloneNode(
     const UIManager *uiManager,
     const ShadowNode::Shared &shadowNode,
-    const SharedShadowNodeSharedList &children,
+    const ShadowNode::SharedListOfShared &children,
     const RawProps *rawProps) {
   auto delegate_ = getDelegateFromUIManager(uiManager);
   auto contextContainer_ = getContextContainerFromUIManager(uiManager);

package/Common/cpp/Fabric/ReanimatedUIManagerBinding.cpp

@@ -17,31 +17,54 @@ void ReanimatedUIManagerBinding::createAndInstallIfNeeded(
         &newestShadowNodesRegistry) {
   // adapted from UIManagerBinding.cpp
   auto uiManagerModuleName = "nativeFabricUIManager";
-  auto uiManagerBinding = std::make_shared<ReanimatedUIManagerBinding>(
-      uiManager, runtimeExecutor, newestShadowNodesRegistry);
-  auto object = jsi::Object::createFromHostObject(runtime, uiManagerBinding);
+
+  auto eventHandler = [&]() -> std::unique_ptr<EventHandler const> {
+    auto uiManagerValue =
+        runtime.global().getProperty(runtime, uiManagerModuleName);
+    if (uiManagerValue.isUndefined()) {
+      return nullptr;
+    }
+
+    auto uiManagerBinding =
+        uiManagerValue.asObject(runtime).asHostObject<UIManagerBinding>(
+            runtime);
+    auto uiManagerBindingPublic =
+        reinterpret_cast<UIManagerBindingPublic *>(&*uiManagerBinding);
+    return std::move(uiManagerBindingPublic->eventHandler_);
+  }();
+
+  auto reanimatedUiManagerBinding =
+      std::make_shared<ReanimatedUIManagerBinding>(
+          uiManager,
+          runtimeExecutor,
+          std::move(eventHandler),
+          newestShadowNodesRegistry);
+  auto object =
+      jsi::Object::createFromHostObject(runtime, reanimatedUiManagerBinding);
   runtime.global().setProperty(runtime, uiManagerModuleName, std::move(object));
 }
 
 ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
     std::shared_ptr<UIManager> uiManager,
     RuntimeExecutor runtimeExecutor,
+    std::unique_ptr<EventHandler const> eventHandler,
     std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry)
     : UIManagerBinding(uiManager, runtimeExecutor),
       uiManager_(std::move(uiManager)),
-      newestShadowNodesRegistry_(newestShadowNodesRegistry) {}
+      newestShadowNodesRegistry_(newestShadowNodesRegistry) {
+  if (eventHandler != nullptr) {
+    reinterpret_cast<UIManagerBindingPublic *>(this)->eventHandler_ =
+        std::move(eventHandler);
+  }
+}
 
 ReanimatedUIManagerBinding::~ReanimatedUIManagerBinding() {}
 
-void ReanimatedUIManagerBinding::invalidate() const {
-  uiManager_->setDelegate(nullptr);
-}
-
 static inline ShadowNode::Shared cloneNode(
     UIManager *uiManager,
     NewestShadowNodesRegistry *newestShadowNodesRegistry,
     const ShadowNode::Shared &shadowNode,
-    const SharedShadowNodeSharedList &children = nullptr,
+    const ShadowNode::SharedListOfShared &children = nullptr,
     const RawProps *rawProps = nullptr) {
   {
     auto lock = newestShadowNodesRegistry->createLock();

package/Common/cpp/Fabric/ShadowTreeCloner.cpp

@@ -0,0 +1,92 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "ShadowTreeCloner.h"
+#include "FabricUtils.h"
+
+namespace reanimated {
+
+ShadowTreeCloner::ShadowTreeCloner(
+    std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry,
+    std::shared_ptr<UIManager> uiManager,
+    SurfaceId surfaceId)
+    : newestShadowNodesRegistry_{newestShadowNodesRegistry},
+      propsParserContext_{
+          surfaceId,
+          *getContextContainerFromUIManager(&*uiManager)} {}
+
+ShadowTreeCloner::~ShadowTreeCloner() {
+#ifdef DEBUG
+  react_native_assert(
+      yogaChildrenUpdates_.empty() &&
+      "Deallocating `ShadowTreeCloner` without calling `updateYogaChildren`.");
+#endif
+}
+
+ShadowNode::Unshared ShadowTreeCloner::cloneWithNewProps(
+    const ShadowNode::Shared &oldRootNode,
+    const ShadowNodeFamily &family,
+    RawProps &&rawProps) {
+  // adapted from ShadowNode::cloneTree
+
+  auto ancestors = family.getAncestors(*oldRootNode);
+
+  if (ancestors.empty()) {
+    return ShadowNode::Unshared{nullptr};
+  }
+
+  auto &parent = ancestors.back();
+  auto &oldShadowNode = parent.first.get().getChildren().at(parent.second);
+
+  const auto newest = newestShadowNodesRegistry_->get(oldShadowNode->getTag());
+
+  const auto &source = newest == nullptr ? oldShadowNode : newest;
+
+  const auto props = source->getComponentDescriptor().cloneProps(
+      propsParserContext_, source->getProps(), rawProps);
+
+  auto newChildNode = source->clone({/* .props = */ props});
+
+  for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+    auto &parentNode = it->first.get();
+    auto childIndex = it->second;
+
+    auto children = parentNode.getChildren();
+    const auto &oldChildNode = *children.at(childIndex);
+    react_native_assert(ShadowNode::sameFamily(oldChildNode, *newChildNode));
+
+    newestShadowNodesRegistry_->set(newChildNode, parentNode.getTag());
+
+    if (!parentNode.getSealed()) {
+      // Optimization: if a ShadowNode is unsealed, we can directly update its
+      // children instead of cloning the whole path to the root node.
+      auto &parentNodeNonConst = const_cast<ShadowNode &>(parentNode);
+      parentNodeNonConst.replaceChild(oldChildNode, newChildNode, childIndex);
+      yogaChildrenUpdates_.insert(&parentNodeNonConst);
+      return std::const_pointer_cast<ShadowNode>(oldRootNode);
+    }
+
+    children[childIndex] = newChildNode;
+
+    newChildNode = parentNode.clone({
+        ShadowNodeFragment::propsPlaceholder(),
+        std::make_shared<ShadowNode::ListOfShared>(children),
+    });
+  }
+
+  return std::const_pointer_cast<ShadowNode>(newChildNode);
+}
+
+void ShadowTreeCloner::updateYogaChildren() {
+  // Unfortunately, `replaceChild` does not update Yoga nodes, so we need to
+  // update them manually here.
+  for (ShadowNode *shadowNode : yogaChildrenUpdates_) {
+    static_cast<YogaLayoutableShadowNode *>(shadowNode)->updateYogaChildren();
+  }
+#ifdef DEBUG
+  yogaChildrenUpdates_.clear();
+#endif
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -13,6 +13,7 @@
 #include "FabricUtils.h"
 #include "NewestShadowNodesRegistry.h"
 #include "ReanimatedUIManagerBinding.h"
+#include "ShadowTreeCloner.h"
 #endif
 
 #include "EventHandlerRegistry.h"
@@ -163,6 +164,10 @@ NativeReanimatedModule::NativeReanimatedModule(
 #else
   updatePropsFunction = platformDepMethodsHolder.updatePropsFunction;
 #endif
+  subscribeForKeyboardEventsFunction =
+      platformDepMethodsHolder.subscribeForKeyboardEvents;
+  unsubscribeFromKeyboardEventsFunction =
+      platformDepMethodsHolder.unsubscribeFromKeyboardEvents;
 }
 
 void NativeReanimatedModule::installCoreFunctions(
@@ -503,56 +508,42 @@ void NativeReanimatedModule::performOperations() {
 
   react_native_assert(uiManager_ != nullptr);
   const auto &shadowTreeRegistry = uiManager_->getShadowTreeRegistry();
-  auto contextContainer = getContextContainerFromUIManager(
-      &*uiManager_); // TODO: use Scheduler::getContextContainer
-  PropsParserContext propsParserContext{surfaceId_, *contextContainer};
   jsi::Runtime &rt = *runtime.get();
 
   shadowTreeRegistry.visit(surfaceId_, [&](ShadowTree const &shadowTree) {
     shadowTree.commit([&](RootShadowNode const &oldRootShadowNode) {
-      // lock once due to performance reasons
-      auto lock = newestShadowNodesRegistry_->createLock();
-
       auto rootNode = oldRootShadowNode.ShadowNode::clone(ShadowNodeFragment{});
 
-      for (const auto &pair : copiedOperationsQueue) {
-        const ShadowNodeFamily &family = pair.first->getFamily();
-        react_native_assert(family.getSurfaceId() == surfaceId_);
-
-        auto newRootNode =
-            rootNode->cloneTree(family, [&](ShadowNode const &oldShadowNode) {
-              const auto newest =
-                  newestShadowNodesRegistry_->get(oldShadowNode.getTag());
+      ShadowTreeCloner shadowTreeCloner{
+          newestShadowNodesRegistry_, uiManager_, surfaceId_};
 
-              const auto &source = newest == nullptr ? oldShadowNode : *newest;
+      {
+        // lock once due to performance reasons
+        auto lock = newestShadowNodesRegistry_->createLock();
 
-              const auto newProps = source.getComponentDescriptor().cloneProps(
-                  propsParserContext,
-                  source.getProps(),
-                  RawProps(rt, *pair.second));
+        for (const auto &pair : copiedOperationsQueue) {
+          const ShadowNodeFamily &family = pair.first->getFamily();
+          react_native_assert(family.getSurfaceId() == surfaceId_);
 
-              return source.clone({/* .props = */ newProps});
-            });
+          auto newRootNode = shadowTreeCloner.cloneWithNewProps(
+              rootNode, family, RawProps(rt, *pair.second));
 
-        if (newRootNode == nullptr) {
-          // this happens when React removed the component but Reanimated still
-          // tries to animate it, let's skip update for this specific component
-          continue;
+          if (newRootNode == nullptr) {
+            // this happens when React removed the component but Reanimated
+            // still tries to animate it, let's skip update for this specific
+            // component
+            continue;
+          }
+          rootNode = newRootNode;
         }
-        rootNode = newRootNode;
 
-        auto ancestors = family.getAncestors(*rootNode);
-        for (const auto &pair : ancestors) {
-          const auto &parent = pair.first.get();
-          const auto &child = parent.getChildren().at(pair.second);
-          newestShadowNodesRegistry_->set(child, parent.getTag());
+        // remove ShadowNodes and its ancestors from NewestShadowNodesRegistry
+        for (auto tag : copiedTagsToRemove) {
+          newestShadowNodesRegistry_->remove(tag);
         }
       }
 
-      // remove ShadowNodes and its ancestors from NewestShadowNodesRegistry
-      for (auto tag : copiedTagsToRemove) {
-        newestShadowNodesRegistry_->remove(tag);
-      }
+      shadowTreeCloner.updateYogaChildren();
 
       return std::static_pointer_cast<RootShadowNode>(rootNode);
     });
@@ -632,4 +623,38 @@ void NativeReanimatedModule::setNewestShadowNodesRegistry(
 }
 #endif // RCT_NEW_ARCH_ENABLED
 
+jsi::Value NativeReanimatedModule::subscribeForKeyboardEvents(
+    jsi::Runtime &rt,
+    const jsi::Value &keyboardEventContainer) {
+  jsi::Object keyboardEventObj = keyboardEventContainer.getObject(rt);
+  std::unordered_map<std::string, std::shared_ptr<ShareableValue>>
+      sharedProperties;
+  std::shared_ptr<ShareableValue> keyboardStateShared = ShareableValue::adapt(
+      rt, keyboardEventObj.getProperty(rt, "state"), this);
+  std::shared_ptr<ShareableValue> heightShared = ShareableValue::adapt(
+      rt, keyboardEventObj.getProperty(rt, "height"), this);
+
+  auto keyboardEventDataUpdater =
+      [this, &rt, keyboardStateShared, heightShared](
+          int keyboardState, int height) {
+        auto &keyboardStateValue =
+            ValueWrapper::asMutableValue(keyboardStateShared->valueContainer);
+        keyboardStateValue->setValue(rt, jsi::Value(keyboardState));
+
+        auto &heightMutableValue =
+            ValueWrapper::asMutableValue(heightShared->valueContainer);
+        heightMutableValue->setValue(rt, jsi::Value(height));
+
+        this->mapperRegistry->execute(*this->runtime);
+      };
+
+  return subscribeForKeyboardEventsFunction(keyboardEventDataUpdater);
+}
+
+void NativeReanimatedModule::unsubscribeFromKeyboardEvents(
+    jsi::Runtime &rt,
+    const jsi::Value &listenerId) {
+  unsubscribeFromKeyboardEventsFunction(listenerId.asNumber());
+}
+
 } // namespace reanimated

package/Common/cpp/NativeModules/NativeReanimatedModuleSpec.cpp

@@ -138,6 +138,25 @@ static jsi::Value SPEC_PREFIX(configureProps)(
   return jsi::Value::undefined();
 }
 
+static jsi::Value SPEC_PREFIX(subscribeForKeyboardEvents)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t count) {
+  return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->subscribeForKeyboardEvents(rt, std::move(args[0]));
+}
+
+static jsi::Value SPEC_PREFIX(unsubscribeFromKeyboardEvents)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t count) {
+  static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->unsubscribeFromKeyboardEvents(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
 NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
     std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule("NativeReanimated", jsInvoker) {
@@ -163,5 +182,9 @@ NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
   methodMap_["unregisterSensor"] =
       MethodMetadata{1, SPEC_PREFIX(unregisterSensor)};
   methodMap_["configureProps"] = MethodMetadata{2, SPEC_PREFIX(configureProps)};
+  methodMap_["subscribeForKeyboardEvents"] =
+      MethodMetadata{1, SPEC_PREFIX(subscribeForKeyboardEvents)};
+  methodMap_["unsubscribeFromKeyboardEvents"] =
+      MethodMetadata{1, SPEC_PREFIX(unsubscribeFromKeyboardEvents)};
 }
 } // namespace reanimated

package/Common/cpp/Tools/RuntimeDecorator.cpp

@@ -71,21 +71,27 @@ void RuntimeDecorator::decorateRuntime(
           1,
           setGlobalConsole));
 
+  auto chronoNow = [](jsi::Runtime &rt,
+                      const jsi::Value &thisValue,
+                      const jsi::Value *args,
+                      size_t count) -> jsi::Value {
+    double now = std::chrono::system_clock::now().time_since_epoch() /
+        std::chrono::milliseconds(1);
+    return jsi::Value(now);
+  };
+
   rt.global().setProperty(
       rt,
       "_chronoNow",
       jsi::Function::createFromHostFunction(
-          rt,
-          jsi::PropNameID::forAscii(rt, "_chronoNow"),
-          0,
-          [](jsi::Runtime &rt,
-             const jsi::Value &thisValue,
-             const jsi::Value *args,
-             size_t count) -> jsi::Value {
-            double now = std::chrono::system_clock::now().time_since_epoch() /
-                std::chrono::milliseconds(1);
-            return jsi::Value(now);
-          }));
+          rt, jsi::PropNameID::forAscii(rt, "_chronoNow"), 0, chronoNow));
+  jsi::Object performance(rt);
+  performance.setProperty(
+      rt,
+      "now",
+      jsi::Function::createFromHostFunction(
+          rt, jsi::PropNameID::forAscii(rt, "now"), 0, chronoNow));
+  rt.global().setProperty(rt, "performance", performance);
 }
 
 void RuntimeDecorator::decorateUIRuntime(

package/Common/cpp/headers/Fabric/FabricUtils.h

@@ -17,6 +17,7 @@ namespace reanimated {
 struct UIManagerBindingPublic {
   void *vtable;
   std::shared_ptr<UIManager> uiManager_;
+  std::unique_ptr<EventHandler const> eventHandler_;
 };
 
 struct UIManagerPublic {
@@ -63,10 +64,10 @@ LayoutMetrics UIManager_getRelativeLayoutMetrics(
     ShadowNode const *ancestorShadowNode,
     LayoutableShadowNode::LayoutInspectingPolicy policy);
 
-SharedShadowNode UIManager_cloneNode(
+ShadowNode::Shared UIManager_cloneNode(
     const UIManager *uiManager,
     const ShadowNode::Shared &shadowNode,
-    const SharedShadowNodeSharedList &children = nullptr,
+    const ShadowNode::SharedListOfShared &children = nullptr,
     const RawProps *rawProps = nullptr);
 
 void UIManager_appendChild(

package/Common/cpp/headers/Fabric/ReanimatedUIManagerBinding.h

@@ -28,6 +28,7 @@ class ReanimatedUIManagerBinding : public UIManagerBinding {
   ReanimatedUIManagerBinding(
       std::shared_ptr<UIManager> uiManager,
       RuntimeExecutor runtimeExecutor,
+      std::unique_ptr<EventHandler const> eventHandler,
       std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry);
 
   ~ReanimatedUIManagerBinding();

package/Common/cpp/headers/Fabric/ShadowTreeCloner.h

@@ -0,0 +1,41 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <set>
+
+#include "NewestShadowNodesRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class ShadowTreeCloner {
+ public:
+  ShadowTreeCloner(
+      std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry,
+      std::shared_ptr<UIManager> uiManager,
+      SurfaceId surfaceId);
+
+  ~ShadowTreeCloner();
+
+  ShadowNode::Unshared cloneWithNewProps(
+      const ShadowNode::Shared &oldRootNode,
+      const ShadowNodeFamily &family,
+      RawProps &&rawProps);
+
+  void updateYogaChildren();
+
+ private:
+  PropsParserContext propsParserContext_;
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+  std::set<ShadowNode *> yogaChildrenUpdates_;
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/headers/NativeModules/NativeReanimatedModule.h

@@ -136,6 +136,12 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       const jsi::Value &interval,
       const jsi::Value &sensorDataContainer) override;
   void unregisterSensor(jsi::Runtime &rt, const jsi::Value &sensorId) override;
+  jsi::Value subscribeForKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &keyboardEventContainer) override;
+  void unsubscribeFromKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &listenerId) override;
 
  private:
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -173,6 +179,9 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
 #endif
 
   std::unordered_set<std::string> nativePropNames_; // filled by configureProps
+
+  KeyboardEventSubscribeFunction subscribeForKeyboardEventsFunction;
+  KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEventsFunction;
 };
 
 } // namespace reanimated

package/Common/cpp/headers/NativeModules/NativeReanimatedModuleSpec.h

@@ -69,6 +69,14 @@ class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
       jsi::Runtime &rt,
       const jsi::Value &sensorId) = 0;
 
+  // keyboard
+  virtual jsi::Value subscribeForKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &keyboardEventContainer) = 0;
+  virtual void unsubscribeFromKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &listenerId) = 0;
+
   // other
   virtual jsi::Value enableLayoutAnimations(
       jsi::Runtime &rt,

package/Common/cpp/headers/Tools/PlatformDepMethodsHolder.h

@@ -61,6 +61,9 @@ using ConfigurePropsFunction = std::function<void(
     jsi::Runtime &rt,
     const jsi::Value &uiProps,
     const jsi::Value &nativeProps)>;
+using KeyboardEventSubscribeFunction =
+    std::function<int(std::function<void(int, int)>)>;
+using KeyboardEventUnsubscribeFunction = std::function<void(int)>;
 
 struct PlatformDepMethodsHolder {
   RequestRender requestRender;
@@ -76,6 +79,8 @@ struct PlatformDepMethodsHolder {
   RegisterSensorFunction registerSensor;
   UnregisterSensorFunction unregisterSensor;
   SetGestureStateFunction setGestureStateFunction;
+  KeyboardEventSubscribeFunction subscribeForKeyboardEvents;
+  KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEvents;
 };
 
 } // namespace reanimated

package/RNReanimated.podspec

@@ -4,14 +4,16 @@ package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
 reactVersion = '0.0.0'
 reactTargetTvOS = false
+isUserApp = false
 
 begin
-  # standard app
+  # user app
   # /appName/node_modules/react-native-reanimated/RNReanimated.podspec
   # /appName/node_modules/react-native/package.json
   reactJson = JSON.parse(File.read(File.join(__dir__, "..", "..", "node_modules", "react-native", "package.json")))
   reactVersion = reactJson["version"]
   reactTargetTvOS = reactJson["name"] == "react-native-tvos"
+  isUserApp = true
 rescue
   begin
     # monorepo
@@ -24,18 +26,39 @@ rescue
     begin
       # Example app in reanimated repo
       # /react-native-reanimated/RNReanimated.podspec
-      # /react-native-reanimated/node_modules/react-native/package.json
-      reactJson = JSON.parse(File.read(File.join(__dir__, "node_modules", "react-native", "package.json")))
+      # /react-native-reanimated/{Example,FabricExample,TVOSExample}/node_modules/react-native/package.json
+      if ENV["ReanimatedTVOSExample"] == "1" then
+        appName = "TVOSExample"
+      elsif ENV["RCT_NEW_ARCH_ENABLED"] == "1" then
+        appName = "FabricExample"
+      else
+        appName = "Example"
+      end
+      reactJson = JSON.parse(File.read(File.join(__dir__, appName, "node_modules", "react-native", "package.json")))
       reactVersion = reactJson["version"]
       reactTargetTvOS = ENV["ReanimatedTVOSExample"] == "1"
     rescue
       # should never happen
       reactVersion = '0.68.0'
-      puts "[RNReanimated] Unable to recognized your `react-native` version! Default `react-native` version: " + reactVersion
+      puts "[RNReanimated] Unable to recognize your `react-native` version! Default `react-native` version: " + reactVersion
     end
   end
 end
 
+if isUserApp
+  libInstances = %x[find ../../ -name "package.json" | grep "/react-native-reanimated/package.json"]
+  libInstancesArray = libInstances.split("\n")
+  if libInstancesArray.length() > 1
+    parsedLocation = ''
+    for location in libInstancesArray
+      location['../../'] = '- '
+      location['/package.json'] = ''
+      parsedLocation += location + "\n"
+    end
+    raise "[Reanimated] Multiple versions of Reanimated were detected. Only one instance of react-native-reanimated can be installed in a project. You need to resolve the conflict manually. Check out the documentation: https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/troubleshooting#multiple-versions-of-reanimated-were-detected \n\nConflict between: \n" + parsedLocation
+  end
+end
+
 rnVersion = reactVersion.split('.')[1]
 
 fabric_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
@@ -47,7 +70,6 @@ end
 
 folly_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32 -DRNVERSION=' + rnVersion
 folly_compiler_flags = folly_flags + ' ' + '-Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2021.06.28.00-v2'
 boost_compiler_flags = '-Wno-documentation'
 fabric_flags = ''
 if fabric_enabled
@@ -94,7 +116,7 @@ Pod::Spec.new do |s|
   if fabric_enabled
     s.dependency "React-RCTFabric"
     s.dependency "React-Codegen"
-    s.dependency "RCT-Folly", folly_version
+    s.dependency "RCT-Folly"
   else
     s.dependency "#{folly_prefix}Folly"
   end