react-native-reanimated 4.0.3 → 4.1.0-jsx-fix

package/Common/cpp/reanimated/CSS/svg/values/SVGStrokeDashArray.cpp

@@ -0,0 +1,119 @@
+#include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
+
+namespace reanimated::css {
+
+SVGStrokeDashArray::SVGStrokeDashArray() : values() {}
+
+SVGStrokeDashArray::SVGStrokeDashArray(const std::vector<SVGLength> &values)
+    : values(values) {}
+
+SVGStrokeDashArray::SVGStrokeDashArray(
+    jsi::Runtime &rt,
+    const jsi::Value &jsiValue) {
+  const auto &array = jsiValue.asObject(rt).asArray(rt);
+  const auto arraySize = array.size(rt);
+  values.reserve(arraySize);
+  for (size_t i = 0; i < arraySize; ++i) {
+    values.emplace_back(rt, array.getValueAtIndex(rt, i));
+  }
+}
+
+SVGStrokeDashArray::SVGStrokeDashArray(const folly::dynamic &value) {
+  for (const auto &value : value) {
+    values.emplace_back(value);
+  }
+}
+
+bool SVGStrokeDashArray::canConstruct(
+    jsi::Runtime &rt,
+    const jsi::Value &jsiValue) {
+  if (!jsiValue.isObject() || !jsiValue.asObject(rt).isArray(rt)) {
+    return false;
+  }
+  const auto &array = jsiValue.asObject(rt).asArray(rt);
+  for (size_t i = 0; i < array.size(rt); ++i) {
+    if (!SVGLength::canConstruct(rt, array.getValueAtIndex(rt, i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SVGStrokeDashArray::canConstruct(const folly::dynamic &value) {
+  return value.isArray() &&
+      std::all_of(value.begin(), value.end(), [](const auto &value) {
+           return SVGLength::canConstruct(value);
+         });
+}
+
+folly::dynamic SVGStrokeDashArray::toDynamic() const {
+  folly::dynamic array = folly::dynamic::array;
+  array.reserve(values.size());
+  for (const auto &value : values) {
+    array.push_back(value.toDynamic());
+  }
+  return array;
+}
+
+std::string SVGStrokeDashArray::toString() const {
+  std::stringstream ss;
+  ss << "{";
+  for (const auto &value : values) {
+    ss << value.toString();
+    if (&value != &values.back()) {
+      ss << ", ";
+    }
+  }
+  ss << "}";
+  return ss.str();
+}
+
+SVGStrokeDashArray SVGStrokeDashArray::interpolate(
+    double progress,
+    const SVGStrokeDashArray &to) const {
+  std::vector<SVGLength> result;
+  auto fromValues = values;
+  auto toValues = to.values;
+
+  // If one of the arrays is empty, we take the fist value from the second
+  // one and put it as the only element of the first (empty) array
+  // (this is how it works on the web)
+  if (fromValues.size() == 0 && toValues.size() > 0) {
+    fromValues = {toValues[0]};
+  }
+  if (toValues.size() == 0 && fromValues.size() > 0) {
+    toValues = {fromValues[0]};
+  }
+
+  const auto fromSize = fromValues.size();
+  const auto toSize = toValues.size();
+
+  // We need to find the least common multiple of the two arrays to get
+  // a smooth interpolation of the dash array pattern
+  const auto resultSize = std::lcm(fromSize, toSize);
+  result.reserve(resultSize);
+
+  for (size_t i = 0; i < resultSize; i++) {
+    result.emplace_back(
+        fromValues[i % fromSize].interpolate(progress, toValues[i % toSize]));
+  }
+
+  return SVGStrokeDashArray(result);
+}
+
+bool SVGStrokeDashArray::operator==(const SVGStrokeDashArray &other) const {
+  return values == other.values;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(
+    std::ostream &os,
+    const SVGStrokeDashArray &strokeDashArray) {
+  os << "SVGStrokeDashArray(" << strokeDashArray.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css

package/Common/cpp/reanimated/CSS/svg/values/SVGStrokeDashArray.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <reanimated/CSS/svg/values/SVGLength.h>
+
+#include <numeric>
+#include <string>
+#include <vector>
+
+namespace reanimated::css {
+
+struct SVGStrokeDashArray : public CSSSimpleValue<SVGStrokeDashArray> {
+  std::vector<SVGLength> values;
+
+  SVGStrokeDashArray();
+  explicit SVGStrokeDashArray(const std::vector<SVGLength> &values);
+  explicit SVGStrokeDashArray(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit SVGStrokeDashArray(const folly::dynamic &value);
+
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  static bool canConstruct(const folly::dynamic &value);
+
+  folly::dynamic toDynamic() const override;
+  std::string toString() const override;
+  SVGStrokeDashArray interpolate(double progress, const SVGStrokeDashArray &to)
+      const override;
+
+  bool operator==(const SVGStrokeDashArray &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(
+      std::ostream &os,
+      const SVGStrokeDashArray &strokeDashArray);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css

package/Common/cpp/reanimated/CSS/{util → utils}/DelayedItemsManager.cpp

@@ -1,4 +1,4 @@
-#include <reanimated/CSS/util/DelayedItemsManager.h>
+#include <reanimated/CSS/utils/DelayedItemsManager.h>
 
 namespace reanimated::css {
 

package/Common/cpp/reanimated/CSS/{util → utils}/algorithms.cpp

@@ -1,4 +1,4 @@
-#include <reanimated/CSS/util/algorithms.h>
+#include <reanimated/CSS/utils/algorithms.h>
 
 namespace reanimated::css {
 

package/Common/cpp/reanimated/CSS/{util → utils}/interpolators.cpp

@@ -1,4 +1,4 @@
-#include <reanimated/CSS/util/interpolators.h>
+#include <reanimated/CSS/utils/interpolators.h>
 
 namespace reanimated::css {
 

package/Common/cpp/reanimated/CSS/utils/keyframes.cpp

@@ -0,0 +1,52 @@
+#include <reanimated/CSS/utils/keyframes.h>
+
+namespace reanimated::css {
+
+std::vector<std::pair<double, jsi::Value>> parseJSIKeyframes(
+    jsi::Runtime &rt,
+    const jsi::Value &keyframes) {
+  if (!keyframes.isObject() || !keyframes.asObject(rt).isArray(rt)) {
+    throw std::invalid_argument(
+        "[Reanimated] Keyframes must be an array of keyframe objects");
+  }
+
+  const auto keyframeArray = keyframes.asObject(rt).asArray(rt);
+  const auto keyframesCount = keyframeArray.size(rt);
+
+  const auto getKeyframeAtIndexOffset = [&](size_t index) -> double {
+    return keyframeArray.getValueAtIndex(rt, index)
+        .asObject(rt)
+        .getProperty(rt, "offset")
+        .asNumber();
+  };
+
+  const bool hasOffset0 = getKeyframeAtIndexOffset(0) == 0;
+  const bool hasOffset1 = getKeyframeAtIndexOffset(keyframesCount - 1) == 1;
+
+  std::vector<std::pair<double, jsi::Value>> result;
+  result.reserve(keyframesCount + (hasOffset0 ? 0 : 1) + (hasOffset1 ? 0 : 1));
+
+  // Insert the keyframe without value at offset 0 if it is not present
+  if (!hasOffset0) {
+    result.emplace_back(0.0, jsi::Value::undefined());
+  }
+
+  // Insert all provided keyframes
+  for (size_t i = 0; i < keyframesCount; ++i) {
+    jsi::Object keyframeObject =
+        keyframeArray.getValueAtIndex(rt, i).asObject(rt);
+    double offset = keyframeObject.getProperty(rt, "offset").asNumber();
+    jsi::Value value = keyframeObject.getProperty(rt, "value");
+
+    result.emplace_back(offset, std::move(value));
+  }
+
+  // Insert the keyframe without value at offset 1 if it is not present
+  if (!hasOffset1) {
+    result.emplace_back(1.0, jsi::Value::undefined());
+  }
+
+  return result;
+}
+
+} // namespace reanimated::css

package/Common/cpp/reanimated/CSS/utils/keyframes.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+using namespace facebook;
+
+std::vector<std::pair<double, jsi::Value>> parseJSIKeyframes(
+    jsi::Runtime &rt,
+    const jsi::Value &keyframes);
+
+} // namespace reanimated::css

package/Common/cpp/reanimated/CSS/{util → utils}/props.cpp

@@ -1,10 +1,13 @@
-#include <reanimated/CSS/util/props.h>
+#include <reanimated/CSS/utils/props.h>
 
 namespace reanimated::css {
 
-bool isDiscreteProperty(const std::string &propName) {
-  const auto it = PROPERTY_INTERPOLATORS_CONFIG.find(propName);
-  if (it == PROPERTY_INTERPOLATORS_CONFIG.end()) {
+bool isDiscreteProperty(
+    const std::string &propName,
+    const std::string &componentName) {
+  const auto &interpolators = getComponentInterpolators(componentName);
+  const auto it = interpolators.find(propName);
+  if (it == interpolators.end()) {
     return false;
   }
   return it->second->isDiscreteProperty();

package/Common/cpp/reanimated/CSS/{util → utils}/props.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <reanimated/CSS/common/definitions.h>
-#include <reanimated/CSS/config/PropertyInterpolatorsConfig.h>
+#include <reanimated/CSS/configs/interpolators/registry.h>
 
 #include <memory>
 #include <string>
@@ -17,7 +17,9 @@ struct ChangedProps {
   const PropertyNames changedPropertyNames;
 };
 
-bool isDiscreteProperty(const std::string &propName);
+bool isDiscreteProperty(
+    const std::string &propName,
+    const std::string &componentName);
 
 // We need to specify it here because there are 2 methods referencing
 // each other in the recursion and areArraysDifferentRecursive must be

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

@@ -129,12 +129,18 @@ void UpdatesRegistryManager::collectPropsToRevertBySurface(
         continue;
       }
 
-      const auto &it = PROPERTY_INTERPOLATORS_CONFIG.find(propName);
-      if (it != PROPERTY_INTERPOLATORS_CONFIG.end()) {
-        filteredStyle[propName] = it->second->getDefaultValue().toDynamic();
-      } else {
-        filteredStyle[propName] = nullptr;
+      const auto &componentName = shadowNode->getComponentName();
+      if (hasInterpolators(componentName)) {
+        const auto &interpolators = getComponentInterpolators(componentName);
+        const auto &it = interpolators.find(propName);
+
+        if (it != interpolators.end()) {
+          filteredStyle[propName] = it->second->getDefaultValue().toDynamic();
+          continue;
+        }
       }
+
+      filteredStyle[propName] = nullptr;
     }
 
     const auto &surfaceId = shadowNode->getSurfaceId();

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

@@ -1,6 +1,8 @@
 #pragma once
-#include <reanimated/CSS/config/PropertyInterpolatorsConfig.h>
-#include <reanimated/CSS/registry/StaticPropsRegistry.h>
+
+#include <reanimated/CSS/configs/interpolators/registry.h>
+#include <reanimated/CSS/registries/StaticPropsRegistry.h>
+
 #include <reanimated/Fabric/ShadowTreeCloner.h>
 #include <reanimated/Fabric/updates/UpdatesRegistry.h>
 

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -59,7 +59,7 @@ void LayoutAnimationsManager::startLayoutAnimation(
     const int tag,
     const LayoutAnimationType type,
     const jsi::Object &values) {
-  std::shared_ptr<Shareable> config;
+  std::shared_ptr<Serializable> config;
   {
     auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
     if (!getConfigsForType(type).contains(tag)) {
@@ -107,7 +107,7 @@ void LayoutAnimationsManager::transferConfigFromNativeID(
   enteringAnimationsForNativeID_.erase(nativeId);
 }
 
-std::unordered_map<int, std::shared_ptr<Shareable>> &
+std::unordered_map<int, std::shared_ptr<Serializable>> &
 LayoutAnimationsManager::getConfigsForType(const LayoutAnimationType type) {
   switch (type) {
     case ENTERING:

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

@@ -2,7 +2,7 @@
 
 #include <reanimated/LayoutAnimations/LayoutAnimationType.h>
 
-#include <worklets/SharedItems/Shareables.h>
+#include <worklets/SharedItems/Serializable.h>
 #include <worklets/Tools/JSLogger.h>
 
 #include <jsi/jsi.h>
@@ -23,7 +23,7 @@ using namespace worklets;
 struct LayoutAnimationConfig {
   int tag;
   LayoutAnimationType type;
-  std::shared_ptr<Shareable> config;
+  std::shared_ptr<Serializable> config;
 };
 
 class LayoutAnimationsManager {
@@ -45,16 +45,16 @@ class LayoutAnimationsManager {
   void transferConfigFromNativeID(const int nativeId, const int tag);
 
  private:
-  std::unordered_map<int, std::shared_ptr<Shareable>> &getConfigsForType(
+  std::unordered_map<int, std::shared_ptr<Serializable>> &getConfigsForType(
       const LayoutAnimationType type);
 
   std::shared_ptr<JSLogger> jsLogger_;
 
-  std::unordered_map<int, std::shared_ptr<Shareable>>
+  std::unordered_map<int, std::shared_ptr<Serializable>>
       enteringAnimationsForNativeID_;
-  std::unordered_map<int, std::shared_ptr<Shareable>> enteringAnimations_;
-  std::unordered_map<int, std::shared_ptr<Shareable>> exitingAnimations_;
-  std::unordered_map<int, std::shared_ptr<Shareable>> layoutAnimations_;
+  std::unordered_map<int, std::shared_ptr<Serializable>> enteringAnimations_;
+  std::unordered_map<int, std::shared_ptr<Serializable>> exitingAnimations_;
+  std::unordered_map<int, std::shared_ptr<Serializable>> layoutAnimations_;
   std::unordered_map<int, bool> shouldAnimateExitingForTag_;
   mutable std::recursive_mutex
       animationsMutex_; // Protects `enteringAnimations_`, `exitingAnimations_`,

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

@@ -157,11 +157,7 @@ void LayoutAnimationsProxy::parseRemoveMutations(
     if (mutation.type == ShadowViewMutation::Remove) {
       updateIndexForMutation(mutation);
       auto tag = mutation.oldChildShadowView.tag;
-#if REACT_NATIVE_MINOR_VERSION >= 78
       auto parentTag = mutation.parentTag;
-#else
-      auto parentTag = mutation.parentShadowView.tag;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
       auto unflattenedParentTag = parentTag; // temporary
 
       std::shared_ptr<MutationNode> mutationNode;
@@ -302,13 +298,8 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
       case ShadowViewMutation::Type::Insert: {
         updateIndexForMutation(mutation);
 
-#if REACT_NATIVE_MINOR_VERSION >= 78
         const auto parentTag = mutation.parentTag;
         const auto mutationParent = parentTag;
-#else
-        const auto parentTag = mutation.parentShadowView.tag;
-        const auto mutationParent = mutation.parentShadowView;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
         if (nodeForTag_.contains(parentTag)) {
           nodeForTag_[parentTag]->applyMutationToIndices(mutation);
         }
@@ -415,14 +406,7 @@ void LayoutAnimationsProxy::addOngoingAnimations(
     updateLayoutMetrics(newView->layoutMetrics, updateValues.frame);
 
     mutations.push_back(ShadowViewMutation::UpdateMutation(
-        *layoutAnimation.currentView,
-        *newView,
-#if REACT_NATIVE_MINOR_VERSION >= 78
-        layoutAnimation.parentTag
-#else
-        *layoutAnimation.parentView
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
-        ));
+        *layoutAnimation.currentView, *newView, layoutAnimation.parentTag));
     layoutAnimation.currentView = newView;
   }
   updateMap.clear();
@@ -588,11 +572,7 @@ void LayoutAnimationsProxy::updateIndexForMutation(
     return;
   }
 
-#if REACT_NATIVE_MINOR_VERSION >= 78
   const auto parentTag = mutation.parentTag;
-#else
-  const auto parentTag = mutation.parentShadowView.tag;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
 
   if (!nodeForTag_.contains(parentTag)) {
     return;
@@ -643,15 +623,9 @@ void LayoutAnimationsProxy::createLayoutAnimation(
           : mutation.newChildShadowView);
   auto currentView = std::make_shared<ShadowView>(oldView);
 
-#if REACT_NATIVE_MINOR_VERSION >= 78
   layoutAnimations_.insert_or_assign(
       tag,
       LayoutAnimation{finalView, currentView, mutation.parentTag, {}, count});
-#else
-  auto parentView = std::make_shared<ShadowView>(mutation.parentShadowView);
-  layoutAnimations_.insert_or_assign(
-      tag, LayoutAnimation{finalView, currentView, parentView, {}, count});
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
 }
 
 void LayoutAnimationsProxy::startEnteringAnimation(
@@ -662,9 +636,6 @@ void LayoutAnimationsProxy::startEnteringAnimation(
 #endif
   auto finalView = std::make_shared<ShadowView>(mutation.newChildShadowView);
   auto current = std::make_shared<ShadowView>(mutation.newChildShadowView);
-#if REACT_NATIVE_MINOR_VERSION < 78
-  auto parent = std::make_shared<ShadowView>(mutation.parentShadowView);
-#endif
 
   auto &viewProps =
       static_cast<const ViewProps &>(*mutation.newChildShadowView.props);
@@ -673,9 +644,6 @@ void LayoutAnimationsProxy::startEnteringAnimation(
   uiScheduler_->scheduleOnUI([weakThis = weak_from_this(),
                               finalView,
                               current,
-#if REACT_NATIVE_MINOR_VERSION < 78
-                              parent,
-#endif // REACT_NATIVE_MINOR_VERSION < 78
                               mutation,
                               opacity,
                               tag]() {
@@ -690,15 +658,7 @@ void LayoutAnimationsProxy::startEnteringAnimation(
       auto lock = std::unique_lock<std::recursive_mutex>(mutex);
       strongThis->layoutAnimations_.insert_or_assign(
           tag,
-          LayoutAnimation{
-              finalView,
-              current,
-#if REACT_NATIVE_MINOR_VERSION >= 78
-              mutation.parentTag,
-#else
-              parent,
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
-              opacity});
+          LayoutAnimation{finalView, current, mutation.parentTag, opacity});
       window = strongThis->surfaceManager.getWindow(
           mutation.newChildShadowView.surfaceId);
     }

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

@@ -22,12 +22,8 @@ class ReanimatedModuleProxy;
 using namespace facebook;
 
 struct LayoutAnimation {
-#if REACT_NATIVE_MINOR_VERSION >= 78
   std::shared_ptr<ShadowView> finalView, currentView;
   Tag parentTag;
-#else
-  std::shared_ptr<ShadowView> finalView, currentView, parentView;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
   std::optional<double> opacity;
   int count = 1;
   LayoutAnimation &operator=(const LayoutAnimation &other) = default;

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.cpp

@@ -30,12 +30,7 @@ Rect SurfaceManager::getWindow(SurfaceId surfaceId) {
 }
 
 void Node::applyMutationToIndices(ShadowViewMutation mutation) {
-#if REACT_NATIVE_MINOR_VERSION >= 78
   const auto parentTag = mutation.parentTag;
-#else
-  const auto parentTag = mutation.parentShadowView.tag;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
-
   if (tag != parentTag) {
     return;
   }