Some cleanup and improvements

Author: MatiPl01

packages/react-native-reanimated/Common/cpp/reanimated/CSS/common/definitions.h

@@ -9,15 +9,7 @@ namespace reanimated::css {
 
 using namespace facebook;
 
-using PropertyNames = std::vector<std::string>;
 using PropertyPath = std::vector<std::string>;
-/**
- * If nullopt - all style properties can trigger transition
- * If empty vector - no style property can trigger transition
- * Otherwise - only specified style properties can trigger transition
- */
-using TransitionProperties = std::optional<PropertyNames>;
-
 using EasingFunction = std::function<double(double)>;
 using ColorChannels = std::array<uint8_t, 4>;
 

packages/react-native-reanimated/Common/cpp/reanimated/CSS/configs/CSSTransitionConfig.cpp

@@ -2,8 +2,6 @@
 
 #include <reanimated/CSS/configs/common.h>
 
-#include <utility>
-
 namespace reanimated::css {
 
 CSSTransitionPropertyUpdates parsePropertyUpdates(jsi::Runtime &rt, const jsi::Object &diffs) {
@@ -31,16 +29,13 @@ CSSTransitionPropertyUpdates parsePropertyUpdates(jsi::Runtime &rt, const jsi::O
 
     result.emplace(
         propertyName,
-        std::make_optional(std::make_pair(
-            diffArray.getValueAtIndex(rt, 0), diffArray.getValueAtIndex(rt, 1))));
+        std::make_optional(std::make_pair(diffArray.getValueAtIndex(rt, 0), diffArray.getValueAtIndex(rt, 1))));
   }
 
   return result;
 }
 
-PartialCSSTransitionPropertySettings parsePartialPropertySettings(
-    jsi::Runtime &rt,
-    const jsi::Object &settings) {
+PartialCSSTransitionPropertySettings parsePartialPropertySettings(jsi::Runtime &rt, const jsi::Object &settings) {
   PartialCSSTransitionPropertySettings result;
 
   if (settings.hasProperty(rt, "duration")) {

packages/react-native-reanimated/Common/cpp/reanimated/CSS/configs/CSSTransitionConfig.h

@@ -7,6 +7,7 @@
 #include <optional>
 #include <string>
 #include <unordered_map>
+#include <utility>
 
 namespace reanimated::css {
 
@@ -19,8 +20,7 @@ struct CSSTransitionPropertySettings {
 
 using CSSTransitionPropertiesSettings = std::unordered_map<std::string, CSSTransitionPropertySettings>;
 
-using CSSTransitionPropertyUpdates =
-    std::unordered_map<std::string, std::optional<std::pair<jsi::Value, jsi::Value>>>;
+using CSSTransitionPropertyUpdates = std::unordered_map<std::string, std::optional<std::pair<jsi::Value, jsi::Value>>>;
 
 struct CSSTransitionConfig {
   CSSTransitionPropertyUpdates properties;
@@ -34,8 +34,7 @@ struct PartialCSSTransitionPropertySettings {
   std::optional<bool> allowDiscrete;
 };
 
-using CSSTransitionPropertySettingsUpdates =
-    std::unordered_map<std::string, PartialCSSTransitionPropertySettings>;
+using CSSTransitionPropertySettingsUpdates = std::unordered_map<std::string, PartialCSSTransitionPropertySettings>;
 
 struct CSSTransitionUpdates {
   CSSTransitionPropertyUpdates properties;

packages/react-native-reanimated/Common/cpp/reanimated/CSS/core/CSSTransition.cpp

@@ -3,6 +3,8 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <utility>
+#include <vector>
 
 namespace reanimated::css {
 
@@ -14,8 +16,7 @@ CSSTransition::CSSTransition(
       viewStylesRepository_(viewStylesRepository),
       settings_(config.settings),
       styleInterpolator_(TransitionStyleInterpolator(shadowNode_->getComponentName(), viewStylesRepository)),
-      progressProvider_(TransitionProgressProvider()) {
-}
+      progressProvider_(TransitionProgressProvider()) {}
 
 std::shared_ptr<const ShadowNode> CSSTransition::getShadowNode() const {
   return shadowNode_;
@@ -48,16 +49,19 @@ void CSSTransition::updateSettings(const CSSTransitionPropertySettingsUpdates &s
   }
 }
 
-folly::dynamic CSSTransition::run(
-    jsi::Runtime &rt,
-    const CSSTransitionPropertyUpdates &propertyUpdates,
-    const double timestamp) {
-  if (!propertyUpdates.empty()) {
-    styleInterpolator_.updateInterpolatedProperties(rt, propertyUpdates);
+folly::dynamic
+CSSTransition::run(jsi::Runtime &rt, const CSSTransitionPropertyUpdates &propertyUpdates, const double timestamp) {
+  const auto reversedPropertyNames = styleInterpolator_.updateInterpolatedProperties(rt, propertyUpdates);
+
+  std::vector<std::string> propertyNames;
+  propertyNames.reserve(propertyUpdates.size());
+  for (const auto &[key, value] : propertyUpdates) {
+    propertyNames.emplace_back(key);
   }
 
-  progressProvider_.runProgressProviders(timestamp, settings_, propertyUpdates);
-  return update(rt, timestamp);
+  progressProvider_.runProgressProviders(timestamp, settings_, propertyNames, reversedPropertyNames);
+
+  return update(timestamp);
 }
 
 folly::dynamic CSSTransition::update(const double timestamp) {

packages/react-native-reanimated/Common/cpp/reanimated/CSS/interpolation/PropertyInterpolator.h

@@ -23,10 +23,9 @@ class PropertyInterpolator {
   virtual folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const = 0;
   virtual folly::dynamic getFirstKeyframeValue() const = 0;
   virtual folly::dynamic getLastKeyframeValue() const = 0;
-  virtual bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const = 0;
 
   virtual void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) = 0;
-  virtual void updateKeyframesFromStyleChange(
+  virtual bool updateKeyframesFromStyleChange(
       jsi::Runtime &rt,
       const jsi::Value &oldStyleValue,
       const jsi::Value &newStyleValue) = 0;

packages/react-native-reanimated/Common/cpp/reanimated/CSS/interpolation/groups/ArrayPropertiesInterpolator.cpp

@@ -11,25 +11,6 @@ ArrayPropertiesInterpolator::ArrayPropertiesInterpolator(
     const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
     : GroupPropertiesInterpolator(propertyPath, viewStylesRepository), factories_(factories) {}
 
-bool ArrayPropertiesInterpolator::equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const {
-  if (!propertyValue.isArray()) {
-    return false;
-  }
-
-  const auto valuesCount = propertyValue.size();
-  if (valuesCount != interpolators_.size()) {
-    return false;
-  }
-
-  for (size_t i = 0; i < valuesCount; ++i) {
-    if (!interpolators_[i]->equalsReversingAdjustedStartValue(propertyValue[i])) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 void ArrayPropertiesInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) {
   const jsi::Array keyframesArray = keyframes.asObject(rt).asArray(rt);
   const size_t valuesCount = keyframesArray.size(rt);
@@ -41,37 +22,31 @@ void ArrayPropertiesInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::V
   }
 }
 
-void ArrayPropertiesInterpolator::updateKeyframesFromStyleChange(
+bool ArrayPropertiesInterpolator::updateKeyframesFromStyleChange(
     jsi::Runtime &rt,
     const jsi::Value &oldStyleValue,
     const jsi::Value &newStyleValue) {
-  const auto getArray = [&rt](const jsi::Value &value) -> std::optional<jsi::Array> {
-    if (!value.isObject()) {
-      return std::nullopt;
-    }
-
-    const auto object = value.asObject(rt);
-    if (!object.isArray(rt)) {
-      return std::nullopt;
-    }
-
-    return object.asArray(rt);
-  };
+  const auto oldStyleArray = oldStyleValue.isUndefined() ? jsi::Array(rt, 0) : oldStyleValue.asObject(rt).asArray(rt);
+  const auto newStyleArray = newStyleValue.isUndefined() ? jsi::Array(rt, 0) : newStyleValue.asObject(rt).asArray(rt);
 
-  const auto oldArray = getArray(oldStyleValue);
-  const auto newArray = getArray(newStyleValue);
-
-  const size_t oldSize = oldArray.has_value() ? oldArray->size(rt) : 0;
-  const size_t newSize = newArray.has_value() ? newArray->size(rt) : 0;
+  const size_t oldSize = oldStyleArray.size(rt);
+  const size_t newSize = newStyleArray.size(rt);
   const size_t valuesCount = std::max(oldSize, newSize);
 
   resizeInterpolators(valuesCount);
 
+  bool areAllPropsReversed = true;
+
   for (size_t i = 0; i < valuesCount; ++i) {
-    const auto oldValue = (oldArray.has_value() && i < oldSize) ? oldArray->getValueAtIndex(rt, i) : jsi::Value::undefined();
-    const auto newValue = (newArray.has_value() && i < newSize) ? newArray->getValueAtIndex(rt, i) : jsi::Value::undefined();
-    interpolators_[i]->updateKeyframesFromStyleChange(rt, oldValue, newValue);
+    // These index checks ensure that interpolation works between 2 arrays
+    // with different lengths
+    areAllPropsReversed &= interpolators_[i]->updateKeyframesFromStyleChange(
+        rt,
+        i < oldSize ? oldStyleArray.getValueAtIndex(rt, i) : jsi::Value::undefined(),
+        i < newSize ? newStyleArray.getValueAtIndex(rt, i) : jsi::Value::undefined());
   }
+
+  return areAllPropsReversed;
 }
 
 folly::dynamic ArrayPropertiesInterpolator::mapInterpolators(

packages/react-native-reanimated/Common/cpp/reanimated/CSS/interpolation/groups/ArrayPropertiesInterpolator.h

@@ -15,10 +15,8 @@ class ArrayPropertiesInterpolator : public GroupPropertiesInterpolator {
       const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
   virtual ~ArrayPropertiesInterpolator() = default;
 
-  bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const override;
-
   void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) override;
-  void updateKeyframesFromStyleChange(
+  bool updateKeyframesFromStyleChange(
       jsi::Runtime &rt,
       const jsi::Value &oldStyleValue,
       const jsi::Value &newStyleValue) override;

packages/react-native-reanimated/Common/cpp/reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.cpp

@@ -12,14 +12,6 @@ RecordPropertiesInterpolator::RecordPropertiesInterpolator(
     const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
     : GroupPropertiesInterpolator(propertyPath, viewStylesRepository), factories_(factories) {}
 
-bool RecordPropertiesInterpolator::equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const {
-  return std::ranges::all_of(propertyValue.items(), [this](const auto &item) {
-    const auto &[propName, propValue] = item;
-    const auto it = interpolators_.find(propName.getString());
-    return it != interpolators_.end() && it->second->equalsReversingAdjustedStartValue(propValue);
-  });
-}
-
 void RecordPropertiesInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) {
   // TODO - maybe add a possibility to remove interpolators that are no longer
   // used (for now, for simplicity, we only add new ones)
@@ -37,50 +29,42 @@ void RecordPropertiesInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::
   }
 }
 
-void RecordPropertiesInterpolator::updateKeyframesFromStyleChange(
+bool RecordPropertiesInterpolator::updateKeyframesFromStyleChange(
     jsi::Runtime &rt,
     const jsi::Value &oldStyleValue,
     const jsi::Value &newStyleValue) {
-  const auto getObject = [&rt](const jsi::Value &value) -> std::optional<jsi::Object> {
-    if (!value.isObject()) {
-      return std::nullopt;
-    }
-
-    const auto object = value.asObject(rt);
-    if (!object.isObject()) {
-      return std::nullopt;
-    }
-
-    return object;
-  };
+  // TODO - maybe add a possibility to remove interpolators that are no longer
+  // used  (for now, for simplicity, we only add new ones)
+  const auto oldStyleObject = oldStyleValue.isUndefined() ? jsi::Object(rt) : oldStyleValue.asObject(rt);
+  const auto newStyleObject = newStyleValue.isUndefined() ? jsi::Object(rt) : newStyleValue.asObject(rt);
 
-  const auto oldObject = getObject(oldStyleValue);
-  const auto newObject = getObject(newStyleValue);
+  const auto oldPropertyNames = oldStyleObject.getPropertyNames(rt);
+  const auto newPropertyNames = newStyleObject.getPropertyNames(rt);
+  const auto oldSize = oldPropertyNames.size(rt);
+  const auto newSize = newPropertyNames.size(rt);
 
   std::unordered_set<std::string> propertyNamesSet;
-  if (oldObject.has_value()) {
-    jsi::Array names = oldObject->getPropertyNames(rt);
-    const size_t count = names.size(rt);
-    for (size_t i = 0; i < count; ++i) {
-      propertyNamesSet.insert(names.getValueAtIndex(rt, i).asString(rt).utf8(rt));
-    }
+  for (size_t i = 0; i < oldSize; ++i) {
+    propertyNamesSet.insert(oldPropertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt));
   }
-  if (newObject.has_value()) {
-    jsi::Array names = newObject->getPropertyNames(rt);
-    const size_t count = names.size(rt);
-    for (size_t i = 0; i < count; ++i) {
-      propertyNamesSet.insert(names.getValueAtIndex(rt, i).asString(rt).utf8(rt));
-    }
+  for (size_t i = 0; i < newSize; ++i) {
+    propertyNamesSet.insert(newPropertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt));
   }
 
+  bool areAllPropsReversed = true;
+
   for (const auto &propertyName : propertyNamesSet) {
     maybeCreateInterpolator(propertyName);
-
-    const auto propId = jsi::PropNameID::forUtf8(rt, propertyName);
-    const auto oldValue = oldObject.has_value() ? oldObject->getProperty(rt, propId) : jsi::Value::undefined();
-    const auto newValue = newObject.has_value() ? newObject->getProperty(rt, propId) : jsi::Value::undefined();
-    interpolators_[propertyName]->updateKeyframesFromStyleChange(rt, oldValue, newValue);
+    const auto propNameID = jsi::PropNameID::forUtf8(rt, propertyName);
+    areAllPropsReversed &= interpolators_[propertyName]->updateKeyframesFromStyleChange(
+        rt,
+        oldStyleObject.hasProperty(rt, propNameID) ? oldStyleObject.getProperty(rt, propNameID)
+                                                   : jsi::Value::undefined(),
+        newStyleObject.hasProperty(rt, propNameID) ? newStyleObject.getProperty(rt, propNameID)
+                                                   : jsi::Value::undefined());
   }
+
+  return areAllPropsReversed;
 }
 
 folly::dynamic RecordPropertiesInterpolator::mapInterpolators(

packages/react-native-reanimated/Common/cpp/reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.h

@@ -16,10 +16,8 @@ class RecordPropertiesInterpolator : public GroupPropertiesInterpolator {
       const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
   virtual ~RecordPropertiesInterpolator() = default;
 
-  bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const override;
-
   void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) override;
-  void updateKeyframesFromStyleChange(
+  bool updateKeyframesFromStyleChange(
       jsi::Runtime &rt,
       const jsi::Value &oldStyleValue,
       const jsi::Value &newStyleValue) override;