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

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSAnimationsRegistry.h

@@ -1,80 +1,80 @@
-#pragma once
-
-#include <reanimated/CSS/configs/CSSAnimationConfig.h>
-#include <reanimated/CSS/core/CSSAnimation.h>
-#include <reanimated/CSS/utils/DelayedItemsManager.h>
-#include <reanimated/CSS/utils/props.h>
-#include <reanimated/Fabric/updates/UpdatesRegistry.h>
-
-#include <memory>
-#include <set>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-namespace reanimated::css {
-
-using CSSAnimationsMap = std::unordered_map<size_t, std::shared_ptr<CSSAnimation>>;
-using CSSAnimationsVector = std::vector<std::shared_ptr<CSSAnimation>>;
-
-class CSSAnimationsRegistry : public UpdatesRegistry, std::enable_shared_from_this<CSSAnimationsRegistry> {
- public:
-  using SettingsUpdates = std::vector<std::pair<size_t, PartialCSSAnimationSettings>>;
-
-  bool isEmpty() const override;
-  bool hasUpdates() const;
-
-  void apply(
-      jsi::Runtime &rt,
-      const std::shared_ptr<const ShadowNode> &shadowNode,
-      const std::optional<std::vector<std::string>> &animationNames,
-      const CSSAnimationsMap &newAnimations,
-      const CSSAnimationSettingsUpdatesMap &settingsUpdates,
-      double timestamp);
-  void remove(Tag viewTag) override;
-
-  void update(double timestamp);
-
- private:
-  using AnimationToIndexMap = std::unordered_map<std::shared_ptr<CSSAnimation>, size_t>;
-  using RunningAnimationIndicesMap = std::unordered_map<Tag, std::set<size_t>>;
-  using AnimationsToRevertMap = std::unordered_map<Tag, std::unordered_set<size_t>>;
-  struct RegistryEntry {
-    const CSSAnimationsVector animationsVector;
-    const AnimationToIndexMap animationToIndexMap;
-  };
-
-  using Registry = std::unordered_map<Tag, RegistryEntry>;
-
-  Registry registry_;
-
-  RunningAnimationIndicesMap runningAnimationIndicesMap_;
-  AnimationsToRevertMap animationsToRevertMap_;
-  DelayedItemsManager<std::shared_ptr<CSSAnimation>> delayedAnimationsManager_;
-
-  CSSAnimationsVector buildAnimationsVector(
-      jsi::Runtime &rt,
-      const std::shared_ptr<const ShadowNode> &shadowNode,
-      const std::optional<std::vector<std::string>> &animationNames,
-      const std::optional<CSSAnimationsMap> &newAnimations) const;
-  AnimationToIndexMap buildAnimationToIndexMap(const CSSAnimationsVector &animationsVector) const;
-  void updateAnimationSettings(
-      const CSSAnimationsVector &animationsVector,
-      const CSSAnimationSettingsUpdatesMap &settingsUpdates,
-      double timestamp);
-
-  void
-  updateViewAnimations(Tag viewTag, const std::vector<size_t> &animationIndices, double timestamp, bool addToBatch);
-  void
-  scheduleOrActivateAnimation(size_t animationIndex, const std::shared_ptr<CSSAnimation> &animation, double timestamp);
-  void removeViewAnimations(Tag viewTag);
-  void applyViewAnimationsStyle(Tag viewTag, double timestamp);
-  void activateDelayedAnimations(double timestamp);
-  void handleAnimationsToRevert(double timestamp);
-
-  static bool addStyleUpdates(folly::dynamic &target, const folly::dynamic &updates, bool shouldOverride);
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/configs/CSSAnimationConfig.h>
+#include <reanimated/CSS/core/CSSAnimation.h>
+#include <reanimated/CSS/utils/DelayedItemsManager.h>
+#include <reanimated/CSS/utils/props.h>
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+
+#include <memory>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+using CSSAnimationsMap = std::unordered_map<size_t, std::shared_ptr<CSSAnimation>>;
+using CSSAnimationsVector = std::vector<std::shared_ptr<CSSAnimation>>;
+
+class CSSAnimationsRegistry : public UpdatesRegistry, std::enable_shared_from_this<CSSAnimationsRegistry> {
+ public:
+  using SettingsUpdates = std::vector<std::pair<size_t, PartialCSSAnimationSettings>>;
+
+  bool isEmpty() const override;
+  bool hasUpdates() const;
+
+  void apply(
+      jsi::Runtime &rt,
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::optional<std::vector<std::string>> &animationNames,
+      const CSSAnimationsMap &newAnimations,
+      const CSSAnimationSettingsUpdatesMap &settingsUpdates,
+      double timestamp);
+  void remove(Tag viewTag) override;
+
+  void update(double timestamp);
+
+ private:
+  using AnimationToIndexMap = std::unordered_map<std::shared_ptr<CSSAnimation>, size_t>;
+  using RunningAnimationIndicesMap = std::unordered_map<Tag, std::set<size_t>>;
+  using AnimationsToRevertMap = std::unordered_map<Tag, std::unordered_set<size_t>>;
+  struct RegistryEntry {
+    const CSSAnimationsVector animationsVector;
+    const AnimationToIndexMap animationToIndexMap;
+  };
+
+  using Registry = std::unordered_map<Tag, RegistryEntry>;
+
+  Registry registry_;
+
+  RunningAnimationIndicesMap runningAnimationIndicesMap_;
+  AnimationsToRevertMap animationsToRevertMap_;
+  DelayedItemsManager<std::shared_ptr<CSSAnimation>> delayedAnimationsManager_;
+
+  CSSAnimationsVector buildAnimationsVector(
+      jsi::Runtime &rt,
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::optional<std::vector<std::string>> &animationNames,
+      const std::optional<CSSAnimationsMap> &newAnimations) const;
+  AnimationToIndexMap buildAnimationToIndexMap(const CSSAnimationsVector &animationsVector) const;
+  void updateAnimationSettings(
+      const CSSAnimationsVector &animationsVector,
+      const CSSAnimationSettingsUpdatesMap &settingsUpdates,
+      double timestamp);
+
+  void
+  updateViewAnimations(Tag viewTag, const std::vector<size_t> &animationIndices, double timestamp, bool addToBatch);
+  void
+  scheduleOrActivateAnimation(size_t animationIndex, const std::shared_ptr<CSSAnimation> &animation, double timestamp);
+  void removeViewAnimations(Tag viewTag);
+  void applyViewAnimationsStyle(Tag viewTag, double timestamp);
+  void activateDelayedAnimations(double timestamp);
+  void handleAnimationsToRevert(double timestamp);
+
+  static bool addStyleUpdates(folly::dynamic &target, const folly::dynamic &updates, bool shouldOverride);
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSKeyframesRegistry.cpp

@@ -1,45 +1,45 @@
-#include <reanimated/CSS/registries/CSSKeyframesRegistry.h>
-
-#include <memory>
-#include <string>
-#include <utility>
-
-namespace reanimated::css {
-
-CSSKeyframesRegistry::CSSKeyframesRegistry(const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
-    : viewStylesRepository_(viewStylesRepository) {}
-
-const CSSKeyframesConfig &CSSKeyframesRegistry::get(
-    const std::string &animationName,
-    const std::string &componentName) {
-  const auto &registryIt = registry_.find(animationName);
-  if (registryIt == registry_.end()) {
-    throw std::runtime_error("[Reanimated] No keyframes with name `" + animationName + "` were registered");
-  }
-
-  const auto &keyframesByComponentName = registryIt->second;
-  const auto &keyframesByComponentNameIt = keyframesByComponentName.find(componentName);
-  if (keyframesByComponentNameIt == keyframesByComponentName.end()) {
-    throw std::runtime_error(
-        "[Reanimated] No keyframes with name `" + animationName + "` were registered for component `" + componentName +
-        "`");
-  }
-
-  return keyframesByComponentNameIt->second;
-}
-
-void CSSKeyframesRegistry::set(
-    const std::string &animationName,
-    const std::string &componentName,
-    CSSKeyframesConfig &&config) {
-  registry_[animationName][componentName] = std::move(config);
-}
-
-void CSSKeyframesRegistry::remove(const std::string &animationName, const std::string &componentName) {
-  registry_[animationName].erase(componentName);
-  if (registry_[animationName].empty()) {
-    registry_.erase(animationName);
-  }
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/registries/CSSKeyframesRegistry.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace reanimated::css {
+
+CSSKeyframesRegistry::CSSKeyframesRegistry(const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : viewStylesRepository_(viewStylesRepository) {}
+
+const CSSKeyframesConfig &CSSKeyframesRegistry::get(
+    const std::string &animationName,
+    const std::string &componentName) {
+  const auto &registryIt = registry_.find(animationName);
+  if (registryIt == registry_.end()) {
+    throw std::runtime_error("[Reanimated] No keyframes with name `" + animationName + "` were registered");
+  }
+
+  const auto &keyframesByComponentName = registryIt->second;
+  const auto &keyframesByComponentNameIt = keyframesByComponentName.find(componentName);
+  if (keyframesByComponentNameIt == keyframesByComponentName.end()) {
+    throw std::runtime_error(
+        "[Reanimated] No keyframes with name `" + animationName + "` were registered for component `" + componentName +
+        "`");
+  }
+
+  return keyframesByComponentNameIt->second;
+}
+
+void CSSKeyframesRegistry::set(
+    const std::string &animationName,
+    const std::string &componentName,
+    CSSKeyframesConfig &&config) {
+  registry_[animationName][componentName] = std::move(config);
+}
+
+void CSSKeyframesRegistry::remove(const std::string &animationName, const std::string &componentName) {
+  registry_[animationName].erase(componentName);
+  if (registry_[animationName].empty()) {
+    registry_.erase(animationName);
+  }
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSKeyframesRegistry.h

@@ -1,29 +1,29 @@
-#pragma once
-
-#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
-#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h>
-#include <reanimated/CSS/misc/ViewStylesRepository.h>
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <utility>
-
-namespace reanimated::css {
-
-class CSSKeyframesRegistry {
- public:
-  explicit CSSKeyframesRegistry(const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
-
-  const CSSKeyframesConfig &get(const std::string &animationName, const std::string &componentName);
-  void set(const std::string &animationName, const std::string &componentName, CSSKeyframesConfig &&config);
-  void remove(const std::string &animationName, const std::string &componentName);
-
- private:
-  using ConfigsByComponentName = std::unordered_map<std::string, CSSKeyframesConfig>;
-
-  std::unordered_map<std::string, ConfigsByComponentName> registry_;
-  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
+#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+namespace reanimated::css {
+
+class CSSKeyframesRegistry {
+ public:
+  explicit CSSKeyframesRegistry(const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+  const CSSKeyframesConfig &get(const std::string &animationName, const std::string &componentName);
+  void set(const std::string &animationName, const std::string &componentName, CSSKeyframesConfig &&config);
+  void remove(const std::string &animationName, const std::string &componentName);
+
+ private:
+  using ConfigsByComponentName = std::unordered_map<std::string, CSSKeyframesConfig>;
+
+  std::unordered_map<std::string, ConfigsByComponentName> registry_;
+  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSTransitionsRegistry.cpp

@@ -1,167 +1,167 @@
-#include <reanimated/CSS/registries/CSSTransitionsRegistry.h>
-
-#include <memory>
-#include <utility>
-
-namespace reanimated::css {
-
-CSSTransitionsRegistry::CSSTransitionsRegistry(
-    const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry,
-    const GetAnimationTimestampFunction &getCurrentTimestamp)
-    : getCurrentTimestamp_(getCurrentTimestamp), staticPropsRegistry_(staticPropsRegistry) {}
-
-bool CSSTransitionsRegistry::isEmpty() const {
-  // The registry is empty if has no registered animations and no updates
-  // stored in the updates registry
-  return UpdatesRegistry::isEmpty() && registry_.empty();
-}
-
-bool CSSTransitionsRegistry::hasUpdates() const {
-  return !runningTransitionTags_.empty() || !delayedTransitionsManager_.empty();
-}
-
-void CSSTransitionsRegistry::add(const std::shared_ptr<CSSTransition> &transition) {
-  const auto &shadowNode = transition->getShadowNode();
-  const auto viewTag = shadowNode->getTag();
-
-  registry_.insert({viewTag, transition});
-  PropsObserver observer = createPropsObserver(viewTag);
-  staticPropsRegistry_->setObserver(viewTag, std::move(observer));
-}
-
-void CSSTransitionsRegistry::remove(const Tag viewTag) {
-  removeFromUpdatesRegistry(viewTag);
-  staticPropsRegistry_->removeObserver(viewTag);
-  delayedTransitionsManager_.remove(viewTag);
-  runningTransitionTags_.erase(viewTag);
-  registry_.erase(viewTag);
-}
-
-void CSSTransitionsRegistry::updateSettings(const Tag viewTag, const PartialCSSTransitionConfig &config) {
-  const auto &transition = registry_[viewTag];
-  transition->updateSettings(config);
-
-  // Replace style overrides with the new ones if transition properties were
-  // updated (we want to keep overrides only for transitioned properties)
-  if (config.properties.has_value()) {
-    updateInUpdatesRegistry(transition, transition->getCurrentInterpolationStyle());
-  }
-}
-
-void CSSTransitionsRegistry::update(const double timestamp) {
-  // Activate all delayed transitions that should start now
-  activateDelayedTransitions(timestamp);
-
-  // Iterate over active transitions and update them
-  for (auto it = runningTransitionTags_.begin(); it != runningTransitionTags_.end();) {
-    const auto &viewTag = *it;
-    const auto &transition = registry_[viewTag];
-
-    const folly::dynamic &updates = transition->update(timestamp);
-    if (!updates.empty()) {
-      addUpdatesToBatch(transition->getShadowNode(), updates);
-    }
-
-    // We remove transition from running and schedule it when animation of one
-    // of properties has finished and the other one is still delayed
-    const auto &minDelay = transition->getMinDelay(timestamp);
-    if (minDelay > 0) {
-      delayedTransitionsManager_.add(timestamp + transition->getMinDelay(timestamp), viewTag);
-    }
-
-    if (transition->getState() != TransitionProgressState::Running) {
-      it = runningTransitionTags_.erase(it);
-    } else {
-      ++it;
-    }
-  }
-}
-
-void CSSTransitionsRegistry::activateDelayedTransitions(const double timestamp) {
-  while (!delayedTransitionsManager_.empty() && delayedTransitionsManager_.top().timestamp <= timestamp) {
-    const auto [_, viewTag] = delayedTransitionsManager_.pop();
-
-    // Add only these transitions which weren't removed in the meantime
-    if (registry_.find(viewTag) != registry_.end()) {
-      runningTransitionTags_.insert(viewTag);
-    }
-  }
-}
-
-void CSSTransitionsRegistry::scheduleOrActivateTransition(const std::shared_ptr<CSSTransition> &transition) {
-  const auto viewTag = transition->getViewTag();
-  const auto currentTimestamp = getCurrentTimestamp_();
-  const auto minDelay = transition->getMinDelay(currentTimestamp);
-
-  // Remove transition from delayed (if it is already added to delayed
-  // transitions)
-  delayedTransitionsManager_.remove(viewTag);
-
-  if (minDelay > 0) {
-    delayedTransitionsManager_.add(currentTimestamp + minDelay, viewTag);
-  } else {
-    runningTransitionTags_.insert(viewTag);
-  }
-}
-
-PropsObserver CSSTransitionsRegistry::createPropsObserver(const Tag viewTag) {
-  return [weakThis = weak_from_this(), viewTag](const folly::dynamic &oldProps, const folly::dynamic &newProps) {
-    auto strongThis = weakThis.lock();
-    if (!strongThis) {
-      return;
-    }
-
-    const auto &transition = strongThis->registry_[viewTag];
-    const auto allowedProperties = transition->getAllowedProperties(oldProps, newProps);
-
-    const auto changedProps = getChangedProps(oldProps, newProps, allowedProperties);
-
-    if (changedProps.changedPropertyNames.empty()) {
-      return;
-    }
-
-    {
-      std::lock_guard<std::mutex> lock{strongThis->mutex_};
-
-      const auto &shadowNode = transition->getShadowNode();
-      const auto &lastUpdates = strongThis->getUpdatesFromRegistry(shadowNode->getTag());
-      const auto &transitionStartStyle = transition->run(changedProps, lastUpdates, strongThis->getCurrentTimestamp_());
-      strongThis->updateInUpdatesRegistry(transition, transitionStartStyle);
-      strongThis->scheduleOrActivateTransition(transition);
-    }
-  };
-}
-
-void CSSTransitionsRegistry::updateInUpdatesRegistry(
-    const std::shared_ptr<CSSTransition> &transition,
-    const folly::dynamic &updates) {
-  const auto &shadowNode = transition->getShadowNode();
-  const auto &lastUpdates = getUpdatesFromRegistry(shadowNode->getTag());
-  const auto &transitionProperties = transition->getProperties();
-
-  folly::dynamic filteredUpdates = folly::dynamic::object;
-
-  if (!transitionProperties.has_value()) {
-    // If transitionProperty is set to 'all' (optional has no value), we have
-    // to keep the result of the previous transition updated with the new
-    // transition starting values
-    if (!lastUpdates.empty()) {
-      filteredUpdates = lastUpdates;
-    }
-  } else if (!lastUpdates.empty()) {
-    // Otherwise, we keep only allowed properties from the last updates
-    // and update the object with the new transition starting values
-    for (const auto &prop : transitionProperties.value()) {
-      if (lastUpdates.count(prop)) {
-        filteredUpdates[prop] = lastUpdates[prop];
-      }
-    }
-  }
-
-  // updated object contains only allowed properties so we don't need
-  // to do additional filtering here
-  filteredUpdates.update(updates);
-  setInUpdatesRegistry(shadowNode, filteredUpdates);
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/registries/CSSTransitionsRegistry.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+CSSTransitionsRegistry::CSSTransitionsRegistry(
+    const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry,
+    const GetAnimationTimestampFunction &getCurrentTimestamp)
+    : getCurrentTimestamp_(getCurrentTimestamp), staticPropsRegistry_(staticPropsRegistry) {}
+
+bool CSSTransitionsRegistry::isEmpty() const {
+  // The registry is empty if has no registered animations and no updates
+  // stored in the updates registry
+  return UpdatesRegistry::isEmpty() && registry_.empty();
+}
+
+bool CSSTransitionsRegistry::hasUpdates() const {
+  return !runningTransitionTags_.empty() || !delayedTransitionsManager_.empty();
+}
+
+void CSSTransitionsRegistry::add(const std::shared_ptr<CSSTransition> &transition) {
+  const auto &shadowNode = transition->getShadowNode();
+  const auto viewTag = shadowNode->getTag();
+
+  registry_.insert({viewTag, transition});
+  PropsObserver observer = createPropsObserver(viewTag);
+  staticPropsRegistry_->setObserver(viewTag, std::move(observer));
+}
+
+void CSSTransitionsRegistry::remove(const Tag viewTag) {
+  removeFromUpdatesRegistry(viewTag);
+  staticPropsRegistry_->removeObserver(viewTag);
+  delayedTransitionsManager_.remove(viewTag);
+  runningTransitionTags_.erase(viewTag);
+  registry_.erase(viewTag);
+}
+
+void CSSTransitionsRegistry::updateSettings(const Tag viewTag, const PartialCSSTransitionConfig &config) {
+  const auto &transition = registry_[viewTag];
+  transition->updateSettings(config);
+
+  // Replace style overrides with the new ones if transition properties were
+  // updated (we want to keep overrides only for transitioned properties)
+  if (config.properties.has_value()) {
+    updateInUpdatesRegistry(transition, transition->getCurrentInterpolationStyle());
+  }
+}
+
+void CSSTransitionsRegistry::update(const double timestamp) {
+  // Activate all delayed transitions that should start now
+  activateDelayedTransitions(timestamp);
+
+  // Iterate over active transitions and update them
+  for (auto it = runningTransitionTags_.begin(); it != runningTransitionTags_.end();) {
+    const auto &viewTag = *it;
+    const auto &transition = registry_[viewTag];
+
+    const folly::dynamic &updates = transition->update(timestamp);
+    if (!updates.empty()) {
+      addUpdatesToBatch(transition->getShadowNode(), updates);
+    }
+
+    // We remove transition from running and schedule it when animation of one
+    // of properties has finished and the other one is still delayed
+    const auto &minDelay = transition->getMinDelay(timestamp);
+    if (minDelay > 0) {
+      delayedTransitionsManager_.add(timestamp + transition->getMinDelay(timestamp), viewTag);
+    }
+
+    if (transition->getState() != TransitionProgressState::Running) {
+      it = runningTransitionTags_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+void CSSTransitionsRegistry::activateDelayedTransitions(const double timestamp) {
+  while (!delayedTransitionsManager_.empty() && delayedTransitionsManager_.top().timestamp <= timestamp) {
+    const auto [_, viewTag] = delayedTransitionsManager_.pop();
+
+    // Add only these transitions which weren't removed in the meantime
+    if (registry_.find(viewTag) != registry_.end()) {
+      runningTransitionTags_.insert(viewTag);
+    }
+  }
+}
+
+void CSSTransitionsRegistry::scheduleOrActivateTransition(const std::shared_ptr<CSSTransition> &transition) {
+  const auto viewTag = transition->getViewTag();
+  const auto currentTimestamp = getCurrentTimestamp_();
+  const auto minDelay = transition->getMinDelay(currentTimestamp);
+
+  // Remove transition from delayed (if it is already added to delayed
+  // transitions)
+  delayedTransitionsManager_.remove(viewTag);
+
+  if (minDelay > 0) {
+    delayedTransitionsManager_.add(currentTimestamp + minDelay, viewTag);
+  } else {
+    runningTransitionTags_.insert(viewTag);
+  }
+}
+
+PropsObserver CSSTransitionsRegistry::createPropsObserver(const Tag viewTag) {
+  return [weakThis = weak_from_this(), viewTag](const folly::dynamic &oldProps, const folly::dynamic &newProps) {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    const auto &transition = strongThis->registry_[viewTag];
+    const auto allowedProperties = transition->getAllowedProperties(oldProps, newProps);
+
+    const auto changedProps = getChangedProps(oldProps, newProps, allowedProperties);
+
+    if (changedProps.changedPropertyNames.empty()) {
+      return;
+    }
+
+    {
+      std::lock_guard<std::mutex> lock{strongThis->mutex_};
+
+      const auto &shadowNode = transition->getShadowNode();
+      const auto &lastUpdates = strongThis->getUpdatesFromRegistry(shadowNode->getTag());
+      const auto &transitionStartStyle = transition->run(changedProps, lastUpdates, strongThis->getCurrentTimestamp_());
+      strongThis->updateInUpdatesRegistry(transition, transitionStartStyle);
+      strongThis->scheduleOrActivateTransition(transition);
+    }
+  };
+}
+
+void CSSTransitionsRegistry::updateInUpdatesRegistry(
+    const std::shared_ptr<CSSTransition> &transition,
+    const folly::dynamic &updates) {
+  const auto &shadowNode = transition->getShadowNode();
+  const auto &lastUpdates = getUpdatesFromRegistry(shadowNode->getTag());
+  const auto &transitionProperties = transition->getProperties();
+
+  folly::dynamic filteredUpdates = folly::dynamic::object;
+
+  if (!transitionProperties.has_value()) {
+    // If transitionProperty is set to 'all' (optional has no value), we have
+    // to keep the result of the previous transition updated with the new
+    // transition starting values
+    if (!lastUpdates.empty()) {
+      filteredUpdates = lastUpdates;
+    }
+  } else if (!lastUpdates.empty()) {
+    // Otherwise, we keep only allowed properties from the last updates
+    // and update the object with the new transition starting values
+    for (const auto &prop : transitionProperties.value()) {
+      if (lastUpdates.count(prop)) {
+        filteredUpdates[prop] = lastUpdates[prop];
+      }
+    }
+  }
+
+  // updated object contains only allowed properties so we don't need
+  // to do additional filtering here
+  filteredUpdates.update(updates);
+  setInUpdatesRegistry(shadowNode, filteredUpdates);
+}
+
+} // namespace reanimated::css