react-native-reanimated 3.13.0-rc.2 → 3.13.0

package/Common/cpp/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -21,7 +21,7 @@ void LayoutAnimationsManager::configureAnimationBatch(
       sharedTransitionConfigs.push_back(std::move(layoutAnimationConfig));
     } else {
 #ifdef RCT_NEW_ARCH_ENABLED
-      if (type == ENTERING){
+      if (type == ENTERING) {
         enteringAnimationsForNativeID_[tag] = config;
         continue;
       }
@@ -132,7 +132,7 @@ void LayoutAnimationsManager::startLayoutAnimation(
       jsi::Value(tag),
       jsi::Value(static_cast<int>(type)),
       values,
-      config->getJSValue(rt));
+      config->toJSValue(rt));
 }
 
 void LayoutAnimationsManager::cancelLayoutAnimation(
@@ -165,6 +165,12 @@ int LayoutAnimationsManager::findPrecedingViewTagForTransition(const int tag) {
   return -1;
 }
 
+const std::vector<int> &LayoutAnimationsManager::getSharedGroup(
+    const int viewTag) {
+  const auto &groupSharedTag = viewTagToSharedTag_[viewTag];
+  return sharedTransitionGroups_[groupSharedTag];
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 void LayoutAnimationsManager::transferConfigFromNativeID(
     const int nativeId,

package/Common/cpp/LayoutAnimations/LayoutAnimationsManager.h

@@ -46,6 +46,7 @@ class LayoutAnimationsManager {
   void transferConfigFromNativeID(const int nativeId, const int tag);
 #endif
   int findPrecedingViewTagForTransition(const int tag);
+  const std::vector<int> &getSharedGroup(const int viewTag);
 #ifndef NDEBUG
   std::string getScreenSharedTagPairString(
       const int screenTag,
@@ -67,7 +68,8 @@ class LayoutAnimationsManager {
 #endif
 
 #ifdef RCT_NEW_ARCH_ENABLED
-  std::unordered_map<int, std::shared_ptr<Shareable>> enteringAnimationsForNativeID_;
+  std::unordered_map<int, std::shared_ptr<Shareable>>
+      enteringAnimationsForNativeID_;
 #endif
   std::unordered_map<int, std::shared_ptr<Shareable>> enteringAnimations_;
   std::unordered_map<int, std::shared_ptr<Shareable>> exitingAnimations_;

package/Common/cpp/LayoutAnimations/LayoutAnimationsProxy.cpp

@@ -14,7 +14,8 @@ namespace reanimated {
 // When animations finish, the Host Tree will represent the most recent Shadow
 // Tree
 // On android this code will be sometimes executed on the JS thread.
-// That's why we have to schedule some of animation manager function on the UI thread
+// That's why we have to schedule some of animation manager function on the UI
+// thread
 std::optional<MountingTransaction> LayoutAnimationsProxy::pullTransaction(
     SurfaceId surfaceId,
     MountingTransaction::Number transactionNumber,
@@ -153,7 +154,8 @@ void LayoutAnimationsProxy::parseRemoveMutations(
       std::shared_ptr<MutationNode> mutationNode;
       std::shared_ptr<Node> node = nodeForTag_[tag],
                             parent = nodeForTag_[parentTag],
-                            unflattenedParent = nodeForTag_[unflattenedParentTag];
+                            unflattenedParent =
+                                nodeForTag_[unflattenedParentTag];
 
       if (!node) {
         mutationNode = std::make_shared<MutationNode>(mutation);
@@ -178,9 +180,9 @@ void LayoutAnimationsProxy::parseRemoveMutations(
         parent = std::make_shared<Node>(parentTag);
         nodeForTag_[parentTag] = parent;
       }
-      
-      if (!unflattenedParent){
-        if (parentTag == unflattenedParentTag){
+
+      if (!unflattenedParent) {
+        if (parentTag == unflattenedParentTag) {
           unflattenedParent = parent;
         } else {
           unflattenedParent = std::make_shared<Node>(unflattenedParentTag);
@@ -225,7 +227,7 @@ void LayoutAnimationsProxy::handleRemovals(
             node, true, true, false, filteredMutations)) {
       filteredMutations.push_back(node->mutation);
       nodeForTag_.erase(node->tag);
-      node->unflattenedParent->removeChildFromUnflattenedTree(node);//???
+      node->unflattenedParent->removeChildFromUnflattenedTree(node); //???
 #ifdef LAYOUT_ANIMATIONS_LOGS
       LOG(INFO) << "delete " << node->tag << std::endl;
 #endif
@@ -268,7 +270,8 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
       case ShadowViewMutation::Type::Insert: {
         updateIndexForMutation(mutation);
         if (nodeForTag_.contains(mutation.parentShadowView.tag)) {
-          nodeForTag_[mutation.parentShadowView.tag]->applyMutationToIndices(mutation);
+          nodeForTag_[mutation.parentShadowView.tag]->applyMutationToIndices(
+              mutation);
         }
 
         if (movedViews.contains(tag)) {
@@ -296,7 +299,8 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
         filteredMutations.push_back(mutation);
 
         // temporarily set opacity to 0 to prevent flickering on android
-        std::shared_ptr<ShadowView> newView = cloneViewWithoutOpacity(mutation, propsParserContext);
+        std::shared_ptr<ShadowView> newView =
+            cloneViewWithoutOpacity(mutation, propsParserContext);
 
         filteredMutations.push_back(ShadowViewMutation::UpdateMutation(
             mutation.newChildShadowView, *newView, mutation.parentShadowView));
@@ -305,7 +309,8 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
 
       case ShadowViewMutation::Type::Update: {
         auto shouldAnimate = hasLayoutChanged(mutation);
-        if (!layoutAnimationsManager_->hasLayoutAnimation(tag, LAYOUT) || (!shouldAnimate && !layoutAnimations_.contains(tag))) {
+        if (!layoutAnimationsManager_->hasLayoutAnimation(tag, LAYOUT) ||
+            (!shouldAnimate && !layoutAnimations_.contains(tag))) {
           // We should cancel any ongoing animation here to ensure that the
           // proper final state is reached for this view However, due to how
           // RNSScreens handle adding headers (a second commit is triggered to
@@ -315,7 +320,7 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
           // TODO: find a better solution for this problem
           filteredMutations.push_back(mutation);
           continue;
-        } else if (!shouldAnimate){
+        } else if (!shouldAnimate) {
           updateOngoingAnimationTarget(tag, mutation);
           continue;
         }
@@ -365,7 +370,9 @@ void LayoutAnimationsProxy::endAnimationsRecursively(
   node->state = DELETED;
   // iterate from the end, so that children
   // with higher indices appear first in the mutations list
-  for (auto it = node->unflattenedChildren.rbegin(); it != node->unflattenedChildren.rend(); it++) {
+  for (auto it = node->unflattenedChildren.rbegin();
+       it != node->unflattenedChildren.rend();
+       it++) {
     auto &subNode = *it;
     if (subNode->state != DELETED) {
       endAnimationsRecursively(subNode, mutations);
@@ -435,7 +442,9 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
 
   // iterate from the end, so that children
   // with higher indices appear first in the mutations list
-  for (auto it = node->unflattenedChildren.rbegin(); it != node->unflattenedChildren.rend(); it++) {
+  for (auto it = node->unflattenedChildren.rbegin();
+       it != node->unflattenedChildren.rend();
+       it++) {
     auto &subNode = *it;
 #ifdef LAYOUT_ANIMATIONS_LOGS
     LOG(INFO) << "child " << subNode->tag << " "
@@ -540,21 +549,28 @@ bool LayoutAnimationsProxy::shouldOverridePullTransaction() const {
   return true;
 }
 
-void LayoutAnimationsProxy::createLayoutAnimation(const ShadowViewMutation &mutation, ShadowView &oldView, const SurfaceId &surfaceId, const int tag) const {
-  
+void LayoutAnimationsProxy::createLayoutAnimation(
+    const ShadowViewMutation &mutation,
+    ShadowView &oldView,
+    const SurfaceId &surfaceId,
+    const int tag) const {
   int count = 1;
   auto layoutAnimationIt = layoutAnimations_.find(tag);
-  
+
   if (layoutAnimationIt != layoutAnimations_.end()) {
     auto &layoutAnimation = layoutAnimationIt->second;
     oldView = *layoutAnimation.currentView;
     count = layoutAnimation.count + 1;
   }
-  
-  auto finalView = std::make_shared<ShadowView>(mutation.type == ShadowViewMutation::Remove ? mutation.oldChildShadowView : mutation.newChildShadowView);
+
+  auto finalView = std::make_shared<ShadowView>(
+      mutation.type == ShadowViewMutation::Remove
+          ? mutation.oldChildShadowView
+          : mutation.newChildShadowView);
   auto currentView = std::make_shared<ShadowView>(oldView);
   auto parentView = std::make_shared<ShadowView>(mutation.parentShadowView);
-  layoutAnimations_.insert_or_assign(tag, LayoutAnimation{finalView, currentView, parentView, {}, count});
+  layoutAnimations_.insert_or_assign(
+      tag, LayoutAnimation{finalView, currentView, parentView, {}, count});
 }
 
 void LayoutAnimationsProxy::startEnteringAnimation(
@@ -627,7 +643,7 @@ void LayoutAnimationsProxy::startLayoutAnimation(
   auto surfaceId = mutation.oldChildShadowView.surfaceId;
   auto oldView = mutation.oldChildShadowView;
   createLayoutAnimation(mutation, oldView, surfaceId, tag);
-      
+
   Snapshot currentValues(oldView, surfaceManager.getWindow(surfaceId));
   Snapshot targetValues(
       mutation.newChildShadowView, surfaceManager.getWindow(surfaceId));
@@ -647,16 +663,18 @@ void LayoutAnimationsProxy::startLayoutAnimation(
     yogaValues.setProperty(uiRuntime_, "targetWidth", targetValues.width);
     yogaValues.setProperty(uiRuntime_, "targetHeight", targetValues.height);
     yogaValues.setProperty(uiRuntime_, "windowWidth", targetValues.windowWidth);
-    yogaValues.setProperty(uiRuntime_, "windowHeight", targetValues.windowHeight);
+    yogaValues.setProperty(
+        uiRuntime_, "windowHeight", targetValues.windowHeight);
     layoutAnimationsManager_->startLayoutAnimation(
         uiRuntime_, tag, LayoutAnimationType::LAYOUT, yogaValues);
   });
 }
 
 void LayoutAnimationsProxy::updateOngoingAnimationTarget(
-  const int tag,
-  const ShadowViewMutation &mutation) const {
-  layoutAnimations_[tag].finalView = std::make_shared<ShadowView>(mutation.newChildShadowView);
+    const int tag,
+    const ShadowViewMutation &mutation) const {
+  layoutAnimations_[tag].finalView =
+      std::make_shared<ShadowView>(mutation.newChildShadowView);
 }
 
 void LayoutAnimationsProxy::maybeCancelAnimation(const int tag) const {
@@ -685,30 +703,37 @@ void LayoutAnimationsProxy::transferConfigFromNativeID(
 // When entering animations start, we temporarily set opacity to 0
 // so that we can immediately insert the view at the right position
 // and schedule the animation on the UI thread
-std::shared_ptr<ShadowView> LayoutAnimationsProxy::cloneViewWithoutOpacity(facebook::react::ShadowViewMutation &mutation, const PropsParserContext &propsParserContext) const {
-  auto newView =
-  std::make_shared<ShadowView>(mutation.newChildShadowView);
+std::shared_ptr<ShadowView> LayoutAnimationsProxy::cloneViewWithoutOpacity(
+    facebook::react::ShadowViewMutation &mutation,
+    const PropsParserContext &propsParserContext) const {
+  auto newView = std::make_shared<ShadowView>(mutation.newChildShadowView);
   folly::dynamic opacity = folly::dynamic::object("opacity", 0);
-  auto newProps = getComponentDescriptorForShadowView(*newView).cloneProps(propsParserContext, newView->props, RawProps(opacity));
+  auto newProps = getComponentDescriptorForShadowView(*newView).cloneProps(
+      propsParserContext, newView->props, RawProps(opacity));
   newView->props = newProps;
   return newView;
 }
 
-void LayoutAnimationsProxy::maybeRestoreOpacity(LayoutAnimation &layoutAnimation, const jsi::Object &newStyle) const{
+void LayoutAnimationsProxy::maybeRestoreOpacity(
+    LayoutAnimation &layoutAnimation,
+    const jsi::Object &newStyle) const {
   if (layoutAnimation.opacity && !newStyle.hasProperty(uiRuntime_, "opacity")) {
-    newStyle.setProperty(uiRuntime_, "opacity", jsi::Value(*layoutAnimation.opacity));
+    newStyle.setProperty(
+        uiRuntime_, "opacity", jsi::Value(*layoutAnimation.opacity));
     layoutAnimation.opacity.reset();
   }
 }
 
-void LayoutAnimationsProxy::maybeUpdateWindowDimensions(facebook::react::ShadowViewMutation &mutation, SurfaceId surfaceId) const {
+void LayoutAnimationsProxy::maybeUpdateWindowDimensions(
+    facebook::react::ShadowViewMutation &mutation,
+    SurfaceId surfaceId) const {
   // This is a hacky way to obtain the window dimensions.
   // We can identify the root, by checking if its tag is equal to the surfaceId
   if (mutation.parentShadowView.tag == surfaceId) {
     surfaceManager.updateWindow(
-                                surfaceId,
-                                mutation.parentShadowView.layoutMetrics.frame.size.width,
-                                mutation.parentShadowView.layoutMetrics.frame.size.height);
+        surfaceId,
+        mutation.parentShadowView.layoutMetrics.frame.size.width,
+        mutation.parentShadowView.layoutMetrics.frame.size.height);
   }
 }
 

package/Common/cpp/LayoutAnimations/LayoutAnimationsProxy.h

@@ -38,18 +38,18 @@ struct LayoutAnimationsProxy : public MountingOverrideDelegate {
   std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
   ContextContainer::Shared contextContainer_;
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
-  jsi::Runtime& uiRuntime_;
+  jsi::Runtime &uiRuntime_;
   const std::shared_ptr<UIScheduler> uiScheduler_;
   LayoutAnimationsProxy(
       std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager,
       SharedComponentDescriptorRegistry componentDescriptorRegistry,
       ContextContainer::Shared contextContainer,
-      jsi::Runtime& uiRuntime_,
+      jsi::Runtime &uiRuntime,
       const std::shared_ptr<UIScheduler> uiScheduler)
       : layoutAnimationsManager_(layoutAnimationsManager),
         contextContainer_(contextContainer),
         componentDescriptorRegistry_(componentDescriptorRegistry),
-        uiRuntime_(uiRuntime_),
+        uiRuntime_(uiRuntime),
         uiScheduler_(uiScheduler) {}
 
   void startEnteringAnimation(const int tag, ShadowViewMutation &mutation)
@@ -73,7 +73,7 @@ struct LayoutAnimationsProxy : public MountingOverrideDelegate {
   void handleRemovals(
       ShadowViewMutationList &filteredMutations,
       std::vector<std::shared_ptr<MutationNode>> &roots) const;
-    
+
   void handleUpdatesAndEnterings(
       ShadowViewMutationList &filteredMutations,
       const std::unordered_map<Tag, ShadowView> &movedViews,
@@ -85,11 +85,21 @@ struct LayoutAnimationsProxy : public MountingOverrideDelegate {
       ShadowViewMutationList &mutations) const;
   void updateOngoingAnimationTarget(
       const int tag,
-      const ShadowViewMutation& mutation) const;
-  std::shared_ptr<ShadowView> cloneViewWithoutOpacity(facebook::react::ShadowViewMutation &mutation, const PropsParserContext &propsParserContext) const;
-  void maybeRestoreOpacity(LayoutAnimation& layoutAnimation, const jsi::Object &newStyle) const;
-  void maybeUpdateWindowDimensions(facebook::react::ShadowViewMutation &mutation, SurfaceId surfaceId) const;
-  void createLayoutAnimation(const ShadowViewMutation &mutation, ShadowView &oldView, const SurfaceId &surfaceId, const int tag) const;
+      const ShadowViewMutation &mutation) const;
+  std::shared_ptr<ShadowView> cloneViewWithoutOpacity(
+      facebook::react::ShadowViewMutation &mutation,
+      const PropsParserContext &propsParserContext) const;
+  void maybeRestoreOpacity(
+      LayoutAnimation &layoutAnimation,
+      const jsi::Object &newStyle) const;
+  void maybeUpdateWindowDimensions(
+      facebook::react::ShadowViewMutation &mutation,
+      SurfaceId surfaceId) const;
+  void createLayoutAnimation(
+      const ShadowViewMutation &mutation,
+      ShadowView &oldView,
+      const SurfaceId &surfaceId,
+      const int tag) const;
 
   void updateIndexForMutation(ShadowViewMutation &mutation) const;
 

package/Common/cpp/LayoutAnimations/LayoutAnimationsUtils.cpp

@@ -3,7 +3,8 @@
 
 namespace reanimated {
 
-std::unordered_map<Tag, UpdateValues> &SurfaceManager::getUpdateMap(SurfaceId surfaceId) {
+std::unordered_map<Tag, UpdateValues> &SurfaceManager::getUpdateMap(
+    SurfaceId surfaceId) {
   auto props = props_.find(surfaceId);
   if (props != props_.end()) {
     return *props->second;
@@ -14,7 +15,10 @@ std::unordered_map<Tag, UpdateValues> &SurfaceManager::getUpdateMap(SurfaceId su
   return *newProps;
 }
 
-void SurfaceManager::updateWindow(const SurfaceId surfaceId, const double windowWidth, const double windowHeight) {
+void SurfaceManager::updateWindow(
+    const SurfaceId surfaceId,
+    const double windowWidth,
+    const double windowHeight) {
   windows_.insert_or_assign(surfaceId, Rect{windowWidth, windowHeight});
 }
 
@@ -48,8 +52,8 @@ void Node::removeChildFromUnflattenedTree(std::shared_ptr<MutationNode> child) {
       break;
     }
   }
-  
-  auto& flattenedChildren = child->parent->children;
+
+  auto &flattenedChildren = child->parent->children;
   for (int i = flattenedChildren.size() - 1; i >= 0; i--) {
     if (flattenedChildren[i]->tag == child->tag) {
       flattenedChildren.erase(flattenedChildren.begin() + i);
@@ -69,13 +73,13 @@ void Node::insertUnflattenedChildren(
   mergeAndSwap(unflattenedChildren, newChildren);
 }
 
-bool Node::isMutationMode(){
+bool Node::isMutationMode() {
   return false;
 }
 
-bool MutationNode::isMutationMode(){
+bool MutationNode::isMutationMode() {
   return true;
 }
-}
+} // namespace reanimated
 
 #endif

package/Common/cpp/LayoutAnimations/LayoutAnimationsUtils.h

@@ -75,10 +75,14 @@ struct Node {
   void removeChildFromUnflattenedTree(std::shared_ptr<MutationNode> child);
   void applyMutationToIndices(ShadowViewMutation mutation);
   void insertChildren(std::vector<std::shared_ptr<MutationNode>> &newChildren);
-  void insertUnflattenedChildren(std::vector<std::shared_ptr<MutationNode>> &newChildren);
+  void insertUnflattenedChildren(
+      std::vector<std::shared_ptr<MutationNode>> &newChildren);
   virtual bool isMutationMode();
   explicit Node(const Tag tag) : tag(tag) {}
-  Node(Node &&node) : children(std::move(node.children)), unflattenedChildren(std::move(node.unflattenedChildren)), tag(node.tag) {}
+  Node(Node &&node)
+      : children(std::move(node.children)),
+        unflattenedChildren(std::move(node.unflattenedChildren)),
+        tag(node.tag) {}
   virtual ~Node() = default;
 };
 
@@ -104,7 +108,8 @@ struct SurfaceManager {
   mutable std::unordered_map<SurfaceId, Rect> windows_;
 
   std::unordered_map<Tag, UpdateValues> &getUpdateMap(SurfaceId surfaceId);
-  void updateWindow(SurfaceId surfaceId, double windowWidth, double windowHeight);
+  void
+  updateWindow(SurfaceId surfaceId, double windowWidth, double windowHeight);
   Rect getWindow(SurfaceId surfaceId);
 };
 
@@ -134,11 +139,14 @@ static inline bool isRNSScreen(std::shared_ptr<MutationNode> node) {
           node->mutation.oldChildShadowView.componentName, "RNSScreen");
 }
 
-static inline bool hasLayoutChanged(const ShadowViewMutation& mutation){
-  return mutation.oldChildShadowView.layoutMetrics.frame != mutation.newChildShadowView.layoutMetrics.frame;
+static inline bool hasLayoutChanged(const ShadowViewMutation &mutation) {
+  return mutation.oldChildShadowView.layoutMetrics.frame !=
+      mutation.newChildShadowView.layoutMetrics.frame;
 }
 
-static inline void mergeAndSwap(std::vector<std::shared_ptr<MutationNode>>& A, std::vector<std::shared_ptr<MutationNode>>& B){
+static inline void mergeAndSwap(
+    std::vector<std::shared_ptr<MutationNode>> &A,
+    std::vector<std::shared_ptr<MutationNode>> &B) {
   std::vector<std::shared_ptr<MutationNode>> merged;
   auto it1 = A.begin(), it2 = B.begin();
   while (it1 != A.end() && it2 != B.end()) {

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -844,7 +844,7 @@ jsi::Value NativeReanimatedModule::measure(
 void NativeReanimatedModule::initializeFabric(
     const std::shared_ptr<UIManager> &uiManager) {
   uiManager_ = uiManager;
-  
+
   initializeLayoutAnimations();
 
   commitHook_ =

package/Common/cpp/NativeModules/NativeReanimatedModule.h

@@ -136,7 +136,7 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec {
   jsi::Value measure(jsi::Runtime &rt, const jsi::Value &shadowNodeValue);
 
   void initializeFabric(const std::shared_ptr<UIManager> &uiManager);
-  
+
   void initializeLayoutAnimations();
 
   std::string obtainPropFromShadowNode(

package/Common/cpp/ReanimatedRuntime/WorkletRuntime.cpp

@@ -97,7 +97,7 @@ jsi::Value WorkletRuntime::executeSync(
   auto result = runGuarded(shareableWorklet);
   auto shareableResult = extractShareableOrThrow(uiRuntime, result);
   lock.unlock();
-  return shareableResult->getJSValue(rt);
+  return shareableResult->toJSValue(rt);
 }
 
 jsi::Value WorkletRuntime::get(

package/Common/cpp/ReanimatedRuntime/WorkletRuntime.h

@@ -39,7 +39,7 @@ class WorkletRuntime : public jsi::HostObject,
       Args &&...args) const {
     jsi::Runtime &rt = *runtime_;
     return runOnRuntimeGuarded(
-        rt, shareableWorklet->getJSValue(rt), std::forward<Args>(args)...);
+        rt, shareableWorklet->toJSValue(rt), std::forward<Args>(args)...);
   }
 
   void runAsyncGuarded(

package/Common/cpp/ReanimatedRuntime/WorkletRuntimeDecorator.cpp

@@ -4,6 +4,8 @@
 #include "Shareables.h"
 #include "WorkletRuntime.h"
 
+#include <vector>
+
 #ifdef ANDROID
 #include "Logger.h"
 #else
@@ -102,21 +104,19 @@ void WorkletRuntimeDecorator::decorate(
             : extractShareableOrThrow<ShareableArray>(
                   rt, argsValue, "[Reanimated] Args must be an array.");
         jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
-          auto remoteFun = shareableRemoteFun->getJSValue(rt);
+          auto remoteFun = shareableRemoteFun->toJSValue(rt);
           if (shareableArgs == nullptr) {
             // fast path for remote function w/o arguments
             remoteFun.asObject(rt).asFunction(rt).call(rt);
           } else {
             auto argsArray =
-                shareableArgs->getJSValue(rt).asObject(rt).asArray(rt);
+                shareableArgs->toJSValue(rt).asObject(rt).asArray(rt);
             auto argsSize = argsArray.size(rt);
-            // number of arguments is typically relatively small so it is ok to
-            // to use VLAs here, hence disabling the lint rule
-            jsi::Value args[argsSize]; // NOLINT(runtime/arrays)
+            std::vector<jsi::Value> args(argsSize);
             for (size_t i = 0; i < argsSize; i++) {
               args[i] = argsArray.getValueAtIndex(rt, i);
             }
-            remoteFun.asObject(rt).asFunction(rt).call(rt, args, argsSize);
+            remoteFun.asObject(rt).asFunction(rt).call(rt, const_cast<const jsi::Value *>(args.data()), args.size());
           }
         });
       });

package/Common/cpp/SharedItems/Shareables.cpp

@@ -78,10 +78,22 @@ jsi::Value makeShareableClone(
     } else {
       if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
         shareable = std::make_shared<RetainingShareable<ShareableObject>>(
-            rt, object, nativeStateSource);
+            rt,
+            object
+#if SUPPORTS_NATIVE_STATE
+            ,
+            nativeStateSource
+#endif // SUPPORTS_NATIVE_STATE
+        );
       } else {
-        shareable =
-            std::make_shared<ShareableObject>(rt, object, nativeStateSource);
+        shareable = std::make_shared<ShareableObject>(
+            rt,
+            object
+#if SUPPORTS_NATIVE_STATE
+            ,
+            nativeStateSource
+#endif // SUPPORTS_NATIVE_STATE
+        );
       }
     }
   } else if (value.isString()) {
@@ -135,7 +147,7 @@ std::shared_ptr<Shareable> Shareable::undefined() {
 }
 
 template <typename BaseClass>
-jsi::Value RetainingShareable<BaseClass>::getJSValue(jsi::Runtime &rt) {
+jsi::Value RetainingShareable<BaseClass>::toJSValue(jsi::Runtime &rt) {
   if (&rt == primaryRuntime_) {
     // TODO: it is suboptimal to generate new object every time getJS is
     // called on host runtime – the objects we are generating already exists
@@ -172,7 +184,7 @@ jsi::Value ShareableArray::toJSValue(jsi::Runtime &rt) {
   auto size = data_.size();
   auto ary = jsi::Array(rt, size);
   for (size_t i = 0; i < size; i++) {
-    ary.setValueAtIndex(rt, i, data_[i]->getJSValue(rt));
+    ary.setValueAtIndex(rt, i, data_[i]->toJSValue(rt));
   }
   return ary;
 }
@@ -198,11 +210,14 @@ ShareableObject::ShareableObject(jsi::Runtime &rt, const jsi::Object &object)
     auto value = extractShareableOrThrow(rt, object.getProperty(rt, key));
     data_.emplace_back(key.utf8(rt), value);
   }
+#if SUPPORTS_NATIVE_STATE
   if (object.hasNativeState(rt)) {
     nativeState_ = object.getNativeState(rt);
   }
+#endif // SUPPORTS_NATIVE_STATE
 }
 
+#if SUPPORTS_NATIVE_STATE
 ShareableObject::ShareableObject(
     jsi::Runtime &rt,
     const jsi::Object &object,
@@ -213,16 +228,18 @@ ShareableObject::ShareableObject(
     nativeState_ = nativeStateSource.asObject(rt).getNativeState(rt);
   }
 }
+#endif // SUPPORTS_NATIVE_STATE
 
 jsi::Value ShareableObject::toJSValue(jsi::Runtime &rt) {
   auto obj = jsi::Object(rt);
   for (size_t i = 0, size = data_.size(); i < size; i++) {
-    obj.setProperty(
-        rt, data_[i].first.c_str(), data_[i].second->getJSValue(rt));
+    obj.setProperty(rt, data_[i].first.c_str(), data_[i].second->toJSValue(rt));
   }
+#if SUPPORTS_NATIVE_STATE
   if (nativeState_ != nullptr) {
     obj.setNativeState(rt, nativeState_);
   }
+#endif // SUPPORTS_NATIVE_STATE
   return obj;
 }
 
@@ -265,7 +282,7 @@ jsi::Value ShareableRemoteFunction::toJSValue(jsi::Runtime &rt) {
 
 jsi::Value ShareableHandle::toJSValue(jsi::Runtime &rt) {
   if (remoteValue_ == nullptr) {
-    auto initObj = initializer_->getJSValue(rt);
+    auto initObj = initializer_->toJSValue(rt);
     auto value = std::make_unique<jsi::Value>(getValueUnpacker(rt).call(
         rt, initObj, jsi::String::createFromAscii(rt, "Handle")));
 

package/Common/cpp/SharedItems/Shareables.h

@@ -62,10 +62,9 @@ inline void cleanupIfRuntimeExists(
 }
 
 class Shareable {
- protected:
+ public:
   virtual jsi::Value toJSValue(jsi::Runtime &rt) = 0;
 
- public:
   virtual ~Shareable();
 
   enum ValueType {
@@ -88,10 +87,6 @@ class Shareable {
 
   explicit Shareable(ValueType valueType) : valueType_(valueType) {}
 
-  virtual jsi::Value getJSValue(jsi::Runtime &rt) {
-    return toJSValue(rt);
-  }
-
   inline ValueType valueType() const {
     return valueType_;
   }
@@ -114,7 +109,7 @@ class RetainingShareable : virtual public BaseClass {
   explicit RetainingShareable(jsi::Runtime &rt, Args &&...args)
       : BaseClass(rt, std::forward<Args>(args)...), primaryRuntime_(&rt) {}
 
-  jsi::Value getJSValue(jsi::Runtime &rt);
+  jsi::Value toJSValue(jsi::Runtime &rt);
 
   ~RetainingShareable() {
     cleanupIfRuntimeExists(secondaryRuntime_, secondaryValue_);
@@ -183,16 +178,26 @@ class ShareableObject : public Shareable {
  public:
   ShareableObject(jsi::Runtime &rt, const jsi::Object &object);
 
+#if defined(USE_HERMES) || REACT_NATIVE_MINOR_VERSION >= 74
+#define SUPPORTS_NATIVE_STATE 1
+#else
+#define SUPPORTS_NATIVE_STATE 0
+#endif
+
+#if SUPPORTS_NATIVE_STATE
   ShareableObject(
       jsi::Runtime &rt,
       const jsi::Object &object,
       const jsi::Value &nativeStateSource);
+#endif // SUPPORTS_NATIVE_STATE
 
   jsi::Value toJSValue(jsi::Runtime &rt) override;
 
  protected:
   std::vector<std::pair<std::string, std::shared_ptr<Shareable>>> data_;
+#if SUPPORTS_NATIVE_STATE
   std::shared_ptr<jsi::NativeState> nativeState_;
+#endif // SUPPORTS_NATIVE_STATE
 };
 
 class ShareableHostObject : public Shareable {

package/android/CMakeLists.txt

@@ -15,7 +15,7 @@ add_compile_options(${folly_FLAGS})
 
 string(APPEND CMAKE_CXX_FLAGS " -DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION} -DREANIMATED_VERSION=${REANIMATED_VERSION} -DHERMES_ENABLE_DEBUGGER=${HERMES_ENABLE_DEBUGGER}")
 
-string(APPEND CMAKE_CXX_FLAGS " -fexceptions -fno-omit-frame-pointer -frtti -fstack-protector-all -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
+string(APPEND CMAKE_CXX_FLAGS " -fexceptions -fno-omit-frame-pointer -frtti -fstack-protector-all -std=c++${CMAKE_CXX_STANDARD} -Wall -Wpedantic -Werror")
 
 if(${IS_NEW_ARCHITECTURE_ENABLED})
     string(APPEND CMAKE_CXX_FLAGS " -DRCT_NEW_ARCH_ENABLED")