@react-native-ohos/react-native-reanimated 4.0.2-beta.1 → 4.1.0-beta.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.h

@@ -16,22 +16,20 @@ 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(
-      const folly::dynamic &oldStyleValue,
-      const folly::dynamic &newStyleValue,
-      const folly::dynamic &lastUpdateValue) override;
+  bool updateKeyframes(jsi::Runtime &rt, const jsi::Value &fromValue, const jsi::Value &toValue) override;
+  /** TODO: unify folly::dynamic and jsi::value versions */
+  bool updateKeyframes(const folly::dynamic &fromValue, const folly::dynamic &toValue) override;
 
  protected:
+  PropertyInterpolatorsRecord interpolators_;
+
   folly::dynamic mapInterpolators(const std::function<folly::dynamic(PropertyInterpolator &)> &callback) const override;
 
   void maybeCreateInterpolator(const std::string &propertyName);
 
  private:
   const InterpolatorFactoriesRecord &factories_;
-  PropertyInterpolatorsRecord interpolators_;
 };
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/operations/OperationsStyleInterpolator.cpp

@@ -14,7 +14,8 @@ OperationsStyleInterpolator::OperationsStyleInterpolator(
     const folly::dynamic &defaultStyleValueDynamic)
     : PropertyInterpolator(propertyPath, viewStylesRepository),
       interpolators_(interpolators),
-      defaultStyleValueDynamic_(defaultStyleValueDynamic) {}
+      defaultStyleValueDynamic_(defaultStyleValueDynamic),
+      reversingAdjustedStartValue_(std::nullopt) {}
 
 folly::dynamic OperationsStyleInterpolator::getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const {
   return viewStylesRepository_->getStyleProp(shadowNode->getTag(), propertyPath_);
@@ -40,31 +41,6 @@ folly::dynamic OperationsStyleInterpolator::getLastKeyframeValue() const {
   return toOperations.has_value() ? convertOperationsToDynamic(toOperations.value()) : defaultStyleValueDynamic_;
 }
 
-bool OperationsStyleInterpolator::equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const {
-  const auto propertyOperations = parseStyleOperations(propertyValue);
-
-  if (!reversingAdjustedStartValue_.has_value()) {
-    return !propertyOperations.has_value();
-  } else if (!propertyOperations.has_value()) {
-    return false;
-  }
-
-  const auto &reversingAdjustedOperationsValue = reversingAdjustedStartValue_.value();
-  const auto &propertyOperationsValue = propertyOperations.value();
-
-  if (reversingAdjustedOperationsValue.size() != propertyOperationsValue.size()) {
-    return false;
-  }
-
-  for (size_t i = 0; i < reversingAdjustedOperationsValue.size(); ++i) {
-    if (*reversingAdjustedOperationsValue[i] != *propertyOperationsValue[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 folly::dynamic OperationsStyleInterpolator::interpolate(
     const std::shared_ptr<const ShadowNode> &shadowNode,
     const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
@@ -126,25 +102,35 @@ void OperationsStyleInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::V
   }
 }
 
-void OperationsStyleInterpolator::updateKeyframesFromStyleChange(
-    const folly::dynamic &oldStyleValue,
-    const folly::dynamic &newStyleValue,
-    const folly::dynamic &lastUpdateValue) {
-  if (oldStyleValue.isNull()) {
-    reversingAdjustedStartValue_ = std::nullopt;
-  } else {
-    reversingAdjustedStartValue_ = parseStyleOperations(oldStyleValue);
-  }
+bool OperationsStyleInterpolator::updateKeyframes(
+    jsi::Runtime &rt,
+    const jsi::Value &fromValue,
+    const jsi::Value &toValue) {
+  const auto fromOperations = parseStyleOperations(rt, fromValue);
+  const auto toOperations = parseStyleOperations(rt, toValue);
+
+  const auto equalsReversingAdjustedStartValue = areStyleOperationsEqual(toOperations, reversingAdjustedStartValue_);
+  reversingAdjustedStartValue_ = keyframes_.empty() ? fromOperations : keyframes_[0]->toOperations;
+
+  keyframes_.clear();
+  keyframes_.reserve(1);
+  keyframes_.emplace_back(createStyleOperationsKeyframe(0, 1, fromOperations, toOperations));
 
-  const auto &prevStyleValue = lastUpdateValue.isNull() ? oldStyleValue : lastUpdateValue;
+  return equalsReversingAdjustedStartValue;
+}
+
+bool OperationsStyleInterpolator::updateKeyframes(const folly::dynamic &fromValue, const folly::dynamic &toValue) {
+  const auto fromOperations = parseStyleOperations(fromValue);
+  const auto toOperations = parseStyleOperations(toValue);
+
+  const auto equalsReversingAdjustedStartValue = areStyleOperationsEqual(toOperations, reversingAdjustedStartValue_);
+  reversingAdjustedStartValue_ = keyframes_.empty() ? fromOperations : keyframes_[0]->toOperations;
 
   keyframes_.clear();
   keyframes_.reserve(1);
-  keyframes_.emplace_back(createStyleOperationsKeyframe(
-      0,
-      1,
-      parseStyleOperations(prevStyleValue).value_or(StyleOperations{}),
-      parseStyleOperations(newStyleValue).value_or(StyleOperations{})));
+  keyframes_.emplace_back(createStyleOperationsKeyframe(0, 1, fromOperations, toOperations));
+
+  return equalsReversingAdjustedStartValue;
 }
 
 std::optional<StyleOperations> OperationsStyleInterpolator::parseStyleOperations(
@@ -262,6 +248,13 @@ folly::dynamic OperationsStyleInterpolator::interpolateOperations(
   return result;
 }
 
+StyleOperationsInterpolationContext OperationsStyleInterpolator::createUpdateContext(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const double fallbackInterpolateThreshold) const {
+  return StyleOperationsInterpolationContext{
+      shadowNode, viewStylesRepository_, interpolators_, fallbackInterpolateThreshold};
+}
+
 folly::dynamic OperationsStyleInterpolator::convertOperationsToDynamic(const StyleOperations &operations) {
   auto result = folly::dynamic::array();
   result.reserve(operations.size());
@@ -273,11 +266,18 @@ folly::dynamic OperationsStyleInterpolator::convertOperationsToDynamic(const Sty
   return result;
 }
 
-StyleOperationsInterpolationContext OperationsStyleInterpolator::createUpdateContext(
-    const std::shared_ptr<const ShadowNode> &shadowNode,
-    const double fallbackInterpolateThreshold) const {
-  return StyleOperationsInterpolationContext{
-      shadowNode, viewStylesRepository_, interpolators_, fallbackInterpolateThreshold};
+bool OperationsStyleInterpolator::areStyleOperationsEqual(
+    const std::optional<StyleOperations> &ops1,
+    const std::optional<StyleOperations> &ops2) {
+  if (ops1.has_value() != ops2.has_value()) {
+    return false;
+  }
+  if (!ops1.has_value()) {
+    return true;
+  }
+  return std::equal(ops1->begin(), ops1->end(), ops2->begin(), ops2->end(), [](const auto &lhs, const auto &rhs) {
+    return *lhs == *rhs;
+  });
 }
 
 // OperationsStyleInterpolatorBase implementation

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/operations/OperationsStyleInterpolator.h

@@ -37,7 +37,6 @@ class OperationsStyleInterpolator : public PropertyInterpolator {
   folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
   folly::dynamic getFirstKeyframeValue() const override;
   folly::dynamic getLastKeyframeValue() const override;
-  bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const override;
 
   folly::dynamic interpolate(
       const std::shared_ptr<const ShadowNode> &shadowNode,
@@ -45,10 +44,9 @@ class OperationsStyleInterpolator : public PropertyInterpolator {
       const double fallbackInterpolateThreshold) const override;
 
   void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) override;
-  void updateKeyframesFromStyleChange(
-      const folly::dynamic &oldStyleValue,
-      const folly::dynamic &newStyleValue,
-      const folly::dynamic &lastUpdateValue) override;
+  bool updateKeyframes(jsi::Runtime &rt, const jsi::Value &fromValue, const jsi::Value &toValue) override;
+  /** TODO: unify folly::dynamic and jsi::value versions */
+  bool updateKeyframes(const folly::dynamic &fromValue, const folly::dynamic &toValue) override;
 
  protected:
   const std::shared_ptr<StyleOperationInterpolators> interpolators_;
@@ -62,8 +60,8 @@ class OperationsStyleInterpolator : public PropertyInterpolator {
  private:
   const folly::dynamic defaultStyleValueDynamic_;
 
-  std::vector<std::shared_ptr<StyleOperationsKeyframe>> keyframes_;
   std::optional<StyleOperations> reversingAdjustedStartValue_;
+  std::vector<std::shared_ptr<StyleOperationsKeyframe>> keyframes_;
 
   std::optional<StyleOperations> parseStyleOperations(jsi::Runtime &rt, const jsi::Value &values) const;
   std::optional<StyleOperations> parseStyleOperations(const folly::dynamic &values) const;
@@ -80,10 +78,13 @@ class OperationsStyleInterpolator : public PropertyInterpolator {
       const StyleOperations &fromOperations,
       const StyleOperations &toOperations,
       double fallbackInterpolateThreshold) const;
-  static folly::dynamic convertOperationsToDynamic(const StyleOperations &operations);
   StyleOperationsInterpolationContext createUpdateContext(
       const std::shared_ptr<const ShadowNode> &shadowNode,
       double fallbackInterpolateThreshold) const;
+  static folly::dynamic convertOperationsToDynamic(const StyleOperations &operations);
+  static bool areStyleOperationsEqual(
+      const std::optional<StyleOperations> &ops1,
+      const std::optional<StyleOperations> &ops2);
 };
 
 template <typename TOperation>

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/operations/StyleOperation.h

@@ -13,65 +13,12 @@ namespace reanimated::css {
 
 using namespace facebook;
 
-//template <typename TOperation>
-//concept ResolvableOp = requires(TOperation operation) {
-//  { operation.value } -> std::convertible_to<typename std::remove_reference_t<decltype(operation.value)>>;
-//  requires Resolvable<std::remove_reference_t<decltype(operation.value)>>;
-//}; // NOLINT(readability/braces)
-
-//template<typename TOperation>
-//struct IsResolvableOpHelper {
-//private:
-//    template<typename T>
-//    static auto test(int) -> decltype(
-//        std::declval<T>().value,
-//        std::declval<typename std::remove_reference_t<decltype(std::declval<T>().value)>>(),
-//        std::declval<Resolvable<typename std::remove_reference_t<decltype(std::declval<T>().value)>>>(),
-//        std::true_type{}
-//    );
-//
-//    template<typename T>
-//    static std::false_type test(...);
-//
-//public:
-//    using type = decltype(test<TOperation>(0));
-//};
-//
-//template<typename TOperation>
-//constexpr bool ResolvableOp = IsResolvableOpHelper<TOperation>::type::value;
-
-
-template <typename T>
-using value_type_t = decltype(std::declval<T>().value);
-
-template <typename T>
-using remove_ref_value_type_t = std::remove_reference_t<value_type_t<T>>;
-
-template <typename T, typename = void>
-struct has_value_member : std::false_type {};
-
-template <typename T>
-struct has_value_member<T, std::void_t<decltype(std::declval<T>().value)>> : std::true_type {};
-
-template <typename T, typename = void>
-struct is_resolvable_op_impl : std::false_type {};
-
-template <typename T>
-struct is_resolvable_op_impl<
-    T,
-    std::enable_if_t<
-        has_value_member<T>::value &&
-        std::is_convertible<value_type_t<T>, remove_ref_value_type_t<T>>::value &&
-        Resolvable<remove_ref_value_type_t<T>>>> : std::true_type {};
-
-
-template <typename TOperation>
-struct is_resolvable_op : reanimated::css::is_resolvable_op_impl<TOperation> {};
-
 template <typename TOperation>
-constexpr bool ResolvableOp = is_resolvable_op<TOperation>::value;
+concept ResolvableOp = requires(TOperation operation) {
+  { operation.value } -> std::convertible_to<typename std::remove_reference_t<decltype(operation.value)>>;
+  requires Resolvable<std::remove_reference_t<decltype(operation.value)>>;
+}; // NOLINT(readability/braces)
 
-//is_resolvable_op_v
 struct StyleOperation {
   uint8_t type;
 

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.cpp

@@ -0,0 +1,23 @@
+#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h>
+
+namespace reanimated::css {
+
+AnimationStyleInterpolator::AnimationStyleInterpolator(
+    const std::string &nativeComponentName,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+    const std::shared_ptr<const PropertyInterpolatorsRecord> &allInterpolators)
+    : RecordPropertiesInterpolator(getComponentInterpolators(nativeComponentName), {}, viewStylesRepository),
+      allInterpolators_(allInterpolators) {}
+
+void AnimationStyleInterpolator::setActiveProperties(const std::unordered_set<std::string> &propertyNames) {
+  interpolators_.clear();
+
+  for (const auto &propertyName : propertyNames) {
+    const auto it = allInterpolators_->find(propertyName);
+    if (it != allInterpolators_->end()) {
+      interpolators_[propertyName] = it->second;
+    }
+  }
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h

@@ -5,6 +5,7 @@
 
 #include <memory>
 #include <string>
+#include <unordered_set>
 
 namespace reanimated::css {
 
@@ -13,14 +14,15 @@ namespace reanimated::css {
 // same as interpolating record properties
 class AnimationStyleInterpolator : public RecordPropertiesInterpolator {
  public:
-  explicit AnimationStyleInterpolator(
-      jsi::Runtime &rt,
-      const jsi::Value &keyframes,
-      const std::string &componentName,
-      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
-      : RecordPropertiesInterpolator(getComponentInterpolators(componentName), {}, viewStylesRepository) {
-    updateKeyframes(rt, keyframes);
-  }
+  AnimationStyleInterpolator(
+      const std::string &nativeComponentName,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+      const std::shared_ptr<const PropertyInterpolatorsRecord> &allInterpolators);
+
+  void setActiveProperties(const std::unordered_set<std::string> &propertyNames);
+
+ private:
+  const std::shared_ptr<const PropertyInterpolatorsRecord> allInterpolators_;
 };
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/styles/AnimationStyleInterpolatorFactory.cpp

@@ -0,0 +1,77 @@
+#include <reanimated/CSS/InterpolatorRegistry.h>
+#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolatorFactory.h>
+#include <reanimated/CSS/utils/interpolators.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+AnimationStyleInterpolatorFactory::AnimationStyleInterpolatorFactory(
+    jsi::Runtime &rt,
+    const jsi::Value &keyframes,
+    std::string nativeComponentName,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : nativeComponentName_(std::move(nativeComponentName)),
+      viewStylesRepository_(viewStylesRepository),
+      factories_(getComponentInterpolators(nativeComponentName_)),
+      interpolatorsByProperty_(
+          std::make_shared<PropertyInterpolatorsRecord>(parseInterpolatorsByProperty(rt, keyframes))),
+      allPropertyNames_(collectPropertyNames(interpolatorsByProperty_)) {}
+
+std::shared_ptr<AnimationStyleInterpolator> AnimationStyleInterpolatorFactory::create(
+    const std::unordered_set<std::string> &propertyNames) const {
+  auto interpolator = std::make_shared<AnimationStyleInterpolator>(
+      nativeComponentName_, viewStylesRepository_, interpolatorsByProperty_);
+  interpolator->setActiveProperties(propertyNames);
+  return interpolator;
+}
+
+std::shared_ptr<AnimationStyleInterpolator> AnimationStyleInterpolatorFactory::create() const {
+  return create(getAllPropertyNames());
+}
+
+const std::unordered_set<std::string> &AnimationStyleInterpolatorFactory::getAllPropertyNames() const {
+  return allPropertyNames_;
+}
+
+PropertyInterpolatorsRecord AnimationStyleInterpolatorFactory::parseInterpolatorsByProperty(
+    jsi::Runtime &rt,
+    const jsi::Value &keyframes) const {
+  PropertyInterpolatorsRecord interpolatorsByProperty;
+  const auto keyframesObject = keyframes.asObject(rt);
+  const auto propertyNames = keyframesObject.getPropertyNames(rt);
+  const auto propertiesCount = propertyNames.size(rt);
+  interpolatorsByProperty.reserve(propertiesCount);
+
+  for (size_t i = 0; i < propertiesCount; ++i) {
+    const auto propertyName = propertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt);
+    const auto propertyKeyframes = keyframesObject.getProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName));
+    auto propertyInterpolator = createPropertyInterpolator(propertyName, {}, factories_, viewStylesRepository_);
+    propertyInterpolator->updateKeyframes(rt, propertyKeyframes);
+    interpolatorsByProperty.emplace(propertyName, std::move(propertyInterpolator));
+  }
+
+  return interpolatorsByProperty;
+}
+
+std::unordered_set<std::string> AnimationStyleInterpolatorFactory::collectPropertyNames(
+    const std::shared_ptr<const PropertyInterpolatorsRecord> &interpolatorsByProperty) {
+  std::unordered_set<std::string> propertyNames;
+  propertyNames.reserve(interpolatorsByProperty->size());
+  for (const auto &[propertyName, _] : *interpolatorsByProperty) {
+    propertyNames.insert(propertyName);
+  }
+  return propertyNames;
+}
+
+folly::dynamic AnimationStyleInterpolatorFactory::getResetStyle(
+    const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  folly::dynamic style = folly::dynamic::object;
+  for (const auto &[name, interpolator] : *interpolatorsByProperty_) {
+    style[name] = interpolator->getResetStyle(shadowNode);
+  }
+  return style;
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/styles/AnimationStyleInterpolatorFactory.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h>
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+
+namespace reanimated::css {
+
+class AnimationStyleInterpolatorFactory {
+ public:
+  AnimationStyleInterpolatorFactory(
+      jsi::Runtime &rt,
+      const jsi::Value &keyframes,
+      std::string nativeComponentName,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+  std::shared_ptr<AnimationStyleInterpolator> create() const;
+  std::shared_ptr<AnimationStyleInterpolator> create(const std::unordered_set<std::string> &propertyNames) const;
+
+  const std::unordered_set<std::string> &getAllPropertyNames() const;
+
+  folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const;
+
+ private:
+  const std::string nativeComponentName_;
+  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+  const InterpolatorFactoriesRecord &factories_;
+  std::shared_ptr<const PropertyInterpolatorsRecord> interpolatorsByProperty_;
+  const std::unordered_set<std::string> allPropertyNames_;
+
+  PropertyInterpolatorsRecord parseInterpolatorsByProperty(jsi::Runtime &rt, const jsi::Value &keyframes) const;
+  static std::unordered_set<std::string> collectPropertyNames(
+      const std::shared_ptr<const PropertyInterpolatorsRecord> &interpolatorsByProperty);
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/styles/TransitionStyleInterpolator.cpp

@@ -7,97 +7,76 @@
 namespace reanimated::css {
 
 TransitionStyleInterpolator::TransitionStyleInterpolator(
-    const std::string &componentName,
+    const std::string &nativeComponentName,
     const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
-    : componentName_(componentName), viewStylesRepository_(viewStylesRepository) {}
-
-std::unordered_set<std::string> TransitionStyleInterpolator::getReversedPropertyNames(
-    const folly::dynamic &newPropertyValues) const {
-  std::unordered_set<std::string> reversedProperties;
-
-  if (!newPropertyValues.isObject()) {
-    return reversedProperties;
-  }
-
-  for (const auto &[propertyName, propertyValue] : newPropertyValues.items()) {
-    const auto propertyNameStr = propertyName.getString();
-    const auto it = interpolators_.find(propertyNameStr);
-    if (it != interpolators_.end() &&
-        // First keyframe value of the previous transition is the reversing
-        // adjusted start value
-        it->second->equalsReversingAdjustedStartValue(propertyValue)) {
-      reversedProperties.insert(propertyNameStr);
-    }
-  }
-
-  return reversedProperties;
-}
+    : nativeComponentName_(nativeComponentName), viewStylesRepository_(viewStylesRepository) {}
 
 folly::dynamic TransitionStyleInterpolator::interpolate(
     const std::shared_ptr<const ShadowNode> &shadowNode,
-    const TransitionProgressProvider &transitionProgressProvider,
-    const std::unordered_set<std::string> &allowDiscreteProperties) const {
+    const TransitionProgressProvider &transitionProgressProvider) const {
   folly::dynamic result = folly::dynamic::object;
 
-  const auto allFallbackInterpolateThreshold = allowDiscreteProperties.contains("all") ? 0.5 : 0;
-
   for (const auto &[propertyName, progressProvider] : transitionProgressProvider.getPropertyProgressProviders()) {
     const auto &interpolator = interpolators_.at(propertyName);
-    const auto fallbackInterpolateThreshold =
-        (allowDiscreteProperties.contains(propertyName)) ? 0.5 : allFallbackInterpolateThreshold;
+    const auto fallbackInterpolateThreshold = (allowDiscreteProperties_.contains(propertyName)) ? 0.5 : 0;
     result[propertyName] = interpolator->interpolate(shadowNode, progressProvider, fallbackInterpolateThreshold);
   }
 
   return result;
 }
 
-void TransitionStyleInterpolator::discardFinishedInterpolators(
-    const TransitionProgressProvider &transitionProgressProvider) {
-  for (const auto &propertyName : transitionProgressProvider.getRemovedProperties()) {
-    interpolators_.erase(propertyName);
-  }
+bool TransitionStyleInterpolator::createOrUpdateInterpolator(
+    jsi::Runtime &rt,
+    const std::string &propertyName,
+    const jsi::Value &fromValue,
+    const jsi::Value &toValue) {
+  const auto &interpolator = getOrCreateInterpolator(propertyName);
+  return interpolator->updateKeyframes(rt, fromValue, toValue);
 }
 
-void TransitionStyleInterpolator::discardIrrelevantInterpolators(
-    const std::unordered_set<std::string> &transitionPropertyNames) {
-  for (auto it = interpolators_.begin(); it != interpolators_.end();) {
-    // Remove property interpolators for properties not specified in the
-    // transition property names
-    if (transitionPropertyNames.find(it->first) == transitionPropertyNames.end()) {
-      it = interpolators_.erase(it);
-    } else {
-      ++it;
-    }
-  }
+bool TransitionStyleInterpolator::createOrUpdateInterpolator(
+    const std::string &propertyName,
+    const folly::dynamic &fromValue,
+    const folly::dynamic &toValue) {
+  const auto &interpolator = getOrCreateInterpolator(propertyName);
+  return interpolator->updateKeyframes(fromValue, toValue);
 }
 
-void TransitionStyleInterpolator::updateInterpolatedProperties(
-    const ChangedProps &changedProps,
-    const folly::dynamic &lastUpdateValue) {
-  const auto &oldPropsObj = changedProps.oldProps;
-  const auto &newPropsObj = changedProps.newProps;
-
-  const auto empty = folly::dynamic();
+void TransitionStyleInterpolator::setAllowDiscrete(const std::string &propertyName, const bool allowDiscrete) {
+  if (allowDiscrete) {
+    allowDiscreteProperties_.insert(propertyName);
+  } else {
+    allowDiscreteProperties_.erase(propertyName);
+  }
+}
 
-  for (const auto &propertyName : changedProps.changedPropertyNames) {
-    auto it = interpolators_.find(propertyName);
-    const auto shouldCreateInterpolator = it == interpolators_.end();
+void TransitionStyleInterpolator::removeProperties(const std::vector<std::string> &propertyNames) {
+  for (const auto &propertyName : propertyNames) {
+    interpolators_.erase(propertyName);
+    allowDiscreteProperties_.erase(propertyName);
+  }
+}
 
-    if (shouldCreateInterpolator) {
-      const auto newInterpolator = createPropertyInterpolator(
-          propertyName, {}, getComponentInterpolators(componentName_), viewStylesRepository_);
-      it = interpolators_.emplace(propertyName, newInterpolator).first;
-    }
+void TransitionStyleInterpolator::removeProperty(const std::string &propertyName) {
+  interpolators_.erase(propertyName);
+}
 
-    const auto &oldValue = oldPropsObj.getDefault(propertyName, empty);
-    const auto &newValue = newPropsObj.getDefault(propertyName, empty);
-    // Pass lastValue only if the interpolator is updated (no new interpolator
-    // was created), otherwise pass an empty value
-    const auto &lastValue =
-        (shouldCreateInterpolator || lastUpdateValue.empty()) ? empty : lastUpdateValue.getDefault(propertyName, empty);
+void TransitionStyleInterpolator::discardFinishedInterpolators(
+    const TransitionProgressProvider &transitionProgressProvider) {
+  const auto &removedProperties = transitionProgressProvider.getRemovedProperties();
+  removeProperties(std::vector<std::string>(removedProperties.begin(), removedProperties.end()));
+}
 
-    it->second->updateKeyframesFromStyleChange(oldValue, newValue, lastValue);
+std::shared_ptr<PropertyInterpolator> TransitionStyleInterpolator::getOrCreateInterpolator(
+    const std::string &propertyName) {
+  if (!interpolators_.contains(propertyName)) {
+    interpolators_.emplace(
+        propertyName,
+        createPropertyInterpolator(
+            propertyName, {}, getComponentInterpolators(nativeComponentName_), viewStylesRepository_));
   }
+
+  return interpolators_.at(propertyName);
 }
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/styles/TransitionStyleInterpolator.h

@@ -9,34 +9,46 @@
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 namespace reanimated::css {
 
 class TransitionStyleInterpolator {
  public:
   TransitionStyleInterpolator(
-      const std::string &componentName,
+      const std::string &nativeComponentName,
       const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
 
-  std::unordered_set<std::string> getReversedPropertyNames(const folly::dynamic &newPropertyValues) const;
-
   folly::dynamic interpolate(
       const std::shared_ptr<const ShadowNode> &shadowNode,
-      const TransitionProgressProvider &transitionProgressProvider,
-      const std::unordered_set<std::string> &allowDiscreteProperties) const;
-
+      const TransitionProgressProvider &transitionProgressProvider) const;
+
+  bool createOrUpdateInterpolator(
+      jsi::Runtime &rt,
+      const std::string &propertyName,
+      const jsi::Value &fromValue,
+      const jsi::Value &toValue);
+  /** TODO: unify folly::dynamic and jsi::value versions */
+  bool createOrUpdateInterpolator(
+      const std::string &propertyName,
+      const folly::dynamic &fromValue,
+      const folly::dynamic &toValue);
+  void setAllowDiscrete(const std::string &propertyName, bool allowDiscrete);
+  void removeProperties(const std::vector<std::string> &propertyNames);
+  void removeProperty(const std::string &propertyName);
   void discardFinishedInterpolators(const TransitionProgressProvider &transitionProgressProvider);
-  void discardIrrelevantInterpolators(const std::unordered_set<std::string> &transitionPropertyNames);
-  void updateInterpolatedProperties(const ChangedProps &changedProps, const folly::dynamic &lastUpdateValue);
 
  private:
   using MapInterpolatorsCallback = std::function<
       folly::dynamic(const std::shared_ptr<PropertyInterpolator> &, const std::shared_ptr<KeyframeProgressProvider> &)>;
 
-  const std::string componentName_;
+  const std::string nativeComponentName_;
   const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
 
   PropertyInterpolatorsRecord interpolators_;
+  std::unordered_set<std::string> allowDiscreteProperties_;
+
+  std::shared_ptr<PropertyInterpolator> getOrCreateInterpolator(const std::string &propertyName);
 };
 
 } // namespace reanimated::css