react-native-reanimated 4.0.0-beta.3 → 4.0.0-beta.5

package/Common/NativeView/CMakeLists.txt

@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+set(ANDROID_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../android)
+set(CODEGEN_JNI_DIR ${ANDROID_DIR}/build/generated/source/codegen/jni)
+set(CODEGEN_COMPONENTS_DIR ${CODEGEN_JNI_DIR}/react/renderer/components/rnreanimated)
+file(
+  GLOB CODEGEN_ORIGINAL_SRCS CONFIGURE_DEPENDS
+  ${CODEGEN_JNI_DIR}/*.cpp
+  ${CODEGEN_COMPONENTS_DIR}/*.cpp
+)
+
+set(CODEGEN_OVERWRITTEN_JNI_DIR .)
+set(CODEGEN_OVERWRITTEN_COMPONENTS_DIR ${CODEGEN_OVERWRITTEN_JNI_DIR}/react/renderer/components/rnreanimated)
+file(
+  GLOB CODEGEN_OVERWRITTEN_SRCS CONFIGURE_DEPENDS 
+  ${CODEGEN_OVERWRITTEN_JNI_DIR}/*.cpp
+  ${CODEGEN_OVERWRITTEN_COMPONENTS_DIR}/*.cpp
+)
+
+add_library(
+  react_codegen_rnreanimated
+  OBJECT
+  ${CODEGEN_OVERWRITTEN_SRCS}
+  ${CODEGEN_ORIGINAL_SRCS}
+)
+
+target_include_directories(
+  react_codegen_rnreanimated
+  PUBLIC
+  ${CODEGEN_OVERWRITTEN_JNI_DIR}
+  ${CODEGEN_OVERWRITTEN_COMPONENTS_DIR}
+  ${CODEGEN_JNI_DIR}
+  ${CODEGEN_COMPONENTS_DIR}
+)
+
+target_link_libraries(
+  react_codegen_rnreanimated
+  fbjni
+  jsi
+  reactnative
+)
+
+target_compile_options(
+  react_codegen_rnreanimated
+  PRIVATE
+  -DLOG_TAG=\"ReactNative\"
+  -fexceptions
+  -frtti
+  -std=c++20
+  -Wall
+)

package/Common/NativeView/react/renderer/components/rnreanimated/ComponentDescriptors.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#include <react/renderer/components/rnreanimated/ReanimatedShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+#include <memory>
+
+namespace facebook::react {
+
+using ReanimatedViewComponentDescriptor =
+    ConcreteComponentDescriptor<ReanimatedShadowNode>;
+
+void rnreanimated_registerComponentDescriptorsFromCodegen(
+    const std::shared_ptr<const ComponentDescriptorProviderRegistry> &registry);
+
+} // namespace facebook::react

package/Common/NativeView/react/renderer/components/rnreanimated/ReanimatedShadowNode.cpp

@@ -0,0 +1,11 @@
+#include <react/renderer/components/rnreanimated/ReanimatedShadowNode.h>
+
+namespace facebook::react {
+
+extern const char ReanimatedViewComponentName[] = "ReanimatedView";
+
+void ReanimatedShadowNode::layout(LayoutContext layoutContext) {
+  YogaLayoutableShadowNode::layout(layoutContext);
+}
+
+} // namespace facebook::react

package/Common/NativeView/react/renderer/components/rnreanimated/ReanimatedShadowNode.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/rnreanimated/EventEmitters.h>
+#include <react/renderer/components/rnreanimated/Props.h>
+#include <react/renderer/components/rnreanimated/ReanimatedViewState.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutContext.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char ReanimatedViewComponentName[];
+
+using ReanimatedViewShadowNodeBase = ConcreteViewShadowNode<
+    ReanimatedViewComponentName,
+    ReanimatedViewProps,
+    ReanimatedViewEventEmitter,
+    ReanimatedViewState>;
+
+class ReanimatedShadowNode final : public ReanimatedViewShadowNodeBase {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  void layout(LayoutContext layoutContext) override;
+};
+
+} // namespace facebook::react

package/Common/NativeView/react/renderer/components/rnreanimated/ReanimatedViewState.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#endif
+
+namespace facebook::react {
+
+class ReanimatedViewState {
+ public:
+  ReanimatedViewState() = default;
+
+#ifdef ANDROID
+  ReanimatedViewState(
+      ReanimatedViewState const &previousState,
+      folly::dynamic data) {}
+  folly::dynamic getDynamic() const {
+    return {};
+  }
+#endif
+};
+
+} // namespace facebook::react

package/Common/cpp/reanimated/CSS/core/CSSAnimation.cpp

@@ -69,11 +69,6 @@ folly::dynamic CSSAnimation::getBackwardsFillStyle() const {
                       : styleInterpolator_->getFirstKeyframeValue();
 }
 
-folly::dynamic CSSAnimation::getForwardsFillStyle() const {
-  return isReversed() ? styleInterpolator_->getFirstKeyframeValue()
-                      : styleInterpolator_->getLastKeyframeValue();
-}
-
 folly::dynamic CSSAnimation::getResetStyle() const {
   return styleInterpolator_->getResetStyle(shadowNode_);
 }
@@ -104,6 +99,8 @@ folly::dynamic CSSAnimation::update(const double timestamp) {
 void CSSAnimation::updateSettings(
     const PartialCSSAnimationSettings &updatedSettings,
     const double timestamp) {
+  progressProvider_->resetProgress();
+
   if (updatedSettings.duration.has_value()) {
     progressProvider_->setDuration(updatedSettings.duration.value());
   }
@@ -131,6 +128,8 @@ void CSSAnimation::updateSettings(
       progressProvider_->play(timestamp);
     }
   }
+
+  progressProvider_->update(timestamp);
 }
 
 } // namespace reanimated::css

package/Common/cpp/reanimated/CSS/core/CSSAnimation.h

@@ -34,7 +34,6 @@ class CSSAnimation {
 
   folly::dynamic getCurrentInterpolationStyle() const;
   folly::dynamic getBackwardsFillStyle() const;
-  folly::dynamic getForwardsFillStyle() const;
   folly::dynamic getResetStyle() const;
 
   void run(double timestamp);

package/Common/cpp/reanimated/CSS/core/CSSTransition.cpp

@@ -33,6 +33,10 @@ folly::dynamic CSSTransition::getCurrentInterpolationStyle() const {
   return styleInterpolator_.interpolate(shadowNode_, progressProvider_);
 }
 
+TransitionProperties CSSTransition::getProperties() const {
+  return properties_;
+}
+
 PropertyNames CSSTransition::getAllowedProperties(
     const folly::dynamic &oldProps,
     const folly::dynamic &newProps) {

package/Common/cpp/reanimated/CSS/core/CSSTransition.h

@@ -24,6 +24,7 @@ class CSSTransition {
   double getMinDelay(double timestamp) const;
   TransitionProgressState getState() const;
   folly::dynamic getCurrentInterpolationStyle() const;
+  TransitionProperties getProperties() const;
   PropertyNames getAllowedProperties(
       const folly::dynamic &oldProps,
       const folly::dynamic &newProps);

package/Common/cpp/reanimated/CSS/progress/AnimationProgressProvider.cpp

@@ -1,7 +1,5 @@
 #include <reanimated/CSS/progress/AnimationProgressProvider.h>
 
-#include <utility>
-
 namespace reanimated::css {
 
 AnimationProgressProvider::AnimationProgressProvider(
@@ -18,6 +16,27 @@ AnimationProgressProvider::AnimationProgressProvider(
       easingFunction_(std::move(easingFunction)),
       keyframeEasingFunctions_(keyframeEasingFunctions) {}
 
+void AnimationProgressProvider::setIterationCount(double iterationCount) {
+  iterationCount_ = iterationCount;
+}
+
+void AnimationProgressProvider::setDirection(AnimationDirection direction) {
+  direction_ = direction;
+}
+
+void AnimationProgressProvider::setEasingFunction(
+    const EasingFunction &easingFunction) {
+  easingFunction_ = easingFunction;
+}
+
+AnimationDirection AnimationProgressProvider::getDirection() const {
+  return direction_;
+}
+
+double AnimationProgressProvider::getGlobalProgress() const {
+  return applyAnimationDirection(rawProgress_.value_or(0));
+}
+
 AnimationProgressState AnimationProgressProvider::getState(
     const double timestamp) const {
   if (shouldFinish(timestamp)) {
@@ -26,7 +45,7 @@ AnimationProgressState AnimationProgressProvider::getState(
   if (pauseTimestamp_ > 0) {
     return AnimationProgressState::Paused;
   }
-  if (!rawProgress_.has_value()) {
+  if (timestamp < getStartTimestamp(timestamp) || !rawProgress_.has_value()) {
     return AnimationProgressState::Pending;
   }
   const auto rawProgress = rawProgress_.value();
@@ -36,6 +55,10 @@ AnimationProgressState AnimationProgressProvider::getState(
   return AnimationProgressState::Running;
 }
 
+double AnimationProgressProvider::getPauseTimestamp() const {
+  return pauseTimestamp_;
+}
+
 double AnimationProgressProvider::getTotalPausedTime(
     const double timestamp) const {
   return pauseTimestamp_ > 0
@@ -137,7 +160,9 @@ double AnimationProgressProvider::updateIterationProgress(
 
   if (deltaIterations > 0) {
     // Return 1 if the current iteration is the last one
-    if (currentIteration_ == iterationCount_) {
+    if (iterationCount_ != -1 &&
+        currentIteration_ + deltaIterations > iterationCount_) {
+      currentIteration_ = iterationCount_;
       return 1;
     }
 

package/Common/cpp/reanimated/CSS/progress/AnimationProgressProvider.h

@@ -7,6 +7,7 @@
 #include <reanimated/CSS/progress/RawProgressProvider.h>
 
 #include <memory>
+#include <utility>
 
 namespace reanimated::css {
 
@@ -29,30 +30,15 @@ class AnimationProgressProvider final : public KeyframeProgressProvider,
       EasingFunction easingFunction,
       const std::shared_ptr<KeyframeEasingFunctions> &keyframeEasingFunctions);
 
-  void setIterationCount(double iterationCount) {
-    resetProgress();
-    iterationCount_ = iterationCount;
-  }
-  void setDirection(AnimationDirection direction) {
-    resetProgress();
-    direction_ = direction;
-  }
-  void setEasingFunction(const EasingFunction &easingFunction) {
-    resetProgress();
-    easingFunction_ = easingFunction;
-  }
+  void setIterationCount(double iterationCount);
+  void setDirection(AnimationDirection direction);
+  void setEasingFunction(const EasingFunction &easingFunction);
 
-  AnimationDirection getDirection() const {
-    return direction_;
-  }
-  double getGlobalProgress() const override {
-    return applyAnimationDirection(rawProgress_.value_or(0));
-  }
+  AnimationDirection getDirection() const;
+  double getGlobalProgress() const override;
   double getKeyframeProgress(double fromOffset, double toOffset) const override;
   AnimationProgressState getState(double timestamp) const;
-  double getPauseTimestamp() const {
-    return pauseTimestamp_;
-  }
+  double getPauseTimestamp() const;
   double getTotalPausedTime(double timestamp) const;
   double getStartTimestamp(double timestamp) const;
 

package/Common/cpp/reanimated/CSS/progress/RawProgressProvider.cpp

@@ -9,12 +9,10 @@ RawProgressProvider::RawProgressProvider(
     : duration_(duration), delay_(delay), creationTimestamp_(timestamp) {}
 
 void RawProgressProvider::setDuration(double duration) {
-  resetProgress();
   duration_ = duration;
 }
 
 void RawProgressProvider::setDelay(double delay) {
-  resetProgress();
   delay_ = delay;
 }
 

package/Common/cpp/reanimated/CSS/registry/CSSAnimationsRegistry.cpp

@@ -274,15 +274,16 @@ void CSSAnimationsRegistry::applyViewAnimationsStyle(
 
     folly::dynamic style;
     const auto &currentState = animation->getState(timestamp);
-    if (currentState == AnimationProgressState::Finished) {
-      if (animation->hasForwardsFillMode()) {
-        style = animation->getForwardsFillStyle();
-      }
-    } else if (
-        startTimestamp == timestamp ||
-        (startTimestamp > timestamp && animation->hasBackwardsFillMode())) {
+    if (startTimestamp > timestamp && animation->hasBackwardsFillMode()) {
       style = animation->getBackwardsFillStyle();
-    } else if (currentState != AnimationProgressState::Pending) {
+    } else if (
+        currentState == AnimationProgressState::Running ||
+        // Animation is paused after start (was running before)
+        (currentState == AnimationProgressState::Paused &&
+         timestamp >= animation->getStartTimestamp(timestamp)) ||
+        // Animation is finished and has fill forwards fill mode
+        (currentState == AnimationProgressState::Finished &&
+         animation->hasForwardsFillMode())) {
       style = animation->getCurrentInterpolationStyle();
     }
 

package/Common/cpp/reanimated/CSS/registry/CSSTransitionsRegistry.cpp

@@ -45,8 +45,8 @@ void CSSTransitionsRegistry::updateSettings(
   // 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()) {
-    const auto &currentStyle = transition->getCurrentInterpolationStyle();
-    setInUpdatesRegistry(transition->getShadowNode(), currentStyle);
+    updateInUpdatesRegistry(
+        transition, transition->getCurrentInterpolationStyle());
   }
 }
 
@@ -138,11 +138,42 @@ PropsObserver CSSTransitionsRegistry::createPropsObserver(const Tag viewTag) {
           strongThis->getUpdatesFromRegistry(shadowNode->getTag());
       const auto &transitionStartStyle = transition->run(
           changedProps, lastUpdates, strongThis->getCurrentTimestamp_());
-
-      strongThis->setInUpdatesRegistry(shadowNode, transitionStartStyle);
+      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];
+      }
+    }
+  }
+
+  // updates object contains only allowed properties so we don't need
+  // to do additional filtering here
+  filteredUpdates.update(updates);
+  setInUpdatesRegistry(shadowNode, filteredUpdates);
+}
+
 } // namespace reanimated::css

package/Common/cpp/reanimated/CSS/registry/CSSTransitionsRegistry.h

@@ -48,6 +48,9 @@ class CSSTransitionsRegistry
   void scheduleOrActivateTransition(
       const std::shared_ptr<CSSTransition> &transition);
   PropsObserver createPropsObserver(Tag viewTag);
+  void updateInUpdatesRegistry(
+      const std::shared_ptr<CSSTransition> &transition,
+      const folly::dynamic &updates);
 };
 
 } // namespace reanimated::css

package/Common/cpp/reanimated/Fabric/ShadowTreeCloner.cpp

@@ -61,7 +61,8 @@ ShadowNode::Unshared cloneShadowTreeWithNewPropsRecursive(
   return shadowNode.clone(
       {mergeProps(shadowNode, propsMap, *family),
        std::make_shared<ShadowNode::ListOfShared>(children),
-       shadowNode.getState()});
+       shadowNode.getState(),
+       false});
 }
 
 RootShadowNode::Unshared cloneShadowTreeWithNewProps(

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

@@ -20,16 +20,12 @@ folly::dynamic UpdatesRegistry::get(const Tag tag) const {
   return it->second.second;
 }
 
-void UpdatesRegistry::flushUpdates(
-    UpdatesBatch &updatesBatch,
-    const bool merge) {
-  std::lock_guard<std::mutex> lock{mutex_};
-
+void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
   auto copiedUpdatesBatch = std::move(updatesBatch_);
   updatesBatch_.clear();
 
   // Store all updates in the registry for later use in the commit hook
-  flushUpdatesToRegistry(copiedUpdatesBatch, merge);
+  flushUpdatesToRegistry(copiedUpdatesBatch);
   // Flush the updates to the updatesBatch used to apply current changes
   for (auto &[shadowNode, props] : copiedUpdatesBatch) {
     updatesBatch.emplace_back(shadowNode, std::move(props));
@@ -86,14 +82,12 @@ void UpdatesRegistry::removeFromUpdatesRegistry(const Tag tag) {
   updatesRegistry_.erase(tag);
 }
 
-void UpdatesRegistry::flushUpdatesToRegistry(
-    const UpdatesBatch &updatesBatch,
-    const bool merge) {
+void UpdatesRegistry::flushUpdatesToRegistry(const UpdatesBatch &updatesBatch) {
   for (auto &[shadowNode, props] : updatesBatch) {
     const auto tag = shadowNode->getTag();
     auto it = updatesRegistry_.find(tag);
 
-    if (it == updatesRegistry_.cend() || !merge) {
+    if (it == updatesRegistry_.cend()) {
       updatesRegistry_[tag] = std::make_pair(shadowNode, props);
     } else {
       it->second.second.update(props);

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

@@ -45,7 +45,7 @@ class UpdatesRegistry {
   void collectPropsToRevert(PropsToRevertMap &propsToRevertMap);
 #endif
 
-  void flushUpdates(UpdatesBatch &updatesBatch, bool merge);
+  void flushUpdates(UpdatesBatch &updatesBatch);
   void collectProps(PropsMap &propsMap);
 
  protected:
@@ -64,7 +64,7 @@ class UpdatesRegistry {
  private:
   UpdatesBatch updatesBatch_;
 
-  void flushUpdatesToRegistry(const UpdatesBatch &updatesBatch, bool merge);
+  void flushUpdatesToRegistry(const UpdatesBatch &updatesBatch);
 
 #ifdef ANDROID
   PropsToRevertMap propsToRevertMap_;

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp

@@ -475,7 +475,6 @@ void ReanimatedModuleProxy::applyCSSAnimations(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeWrapper,
     const jsi::Value &animationUpdates) {
-  cssAnimationsRegistry_->lock();
   auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
   const auto timestamp = getCssTimestamp();
   const auto updates = parseCSSAnimationUpdates(rt, animationUpdates);
@@ -506,19 +505,22 @@ void ReanimatedModuleProxy::applyCSSAnimations(
     }
   }
 
-  cssAnimationsRegistry_->apply(
-      rt,
-      shadowNode,
-      updates.animationNames,
-      std::move(newAnimations),
-      updates.settingsUpdates,
-      timestamp);
+  {
+    auto lock = cssAnimationsRegistry_->lock();
+    cssAnimationsRegistry_->apply(
+        rt,
+        shadowNode,
+        updates.animationNames,
+        std::move(newAnimations),
+        updates.settingsUpdates,
+        timestamp);
+  }
 
   maybeRunCSSLoop();
 }
 
 void ReanimatedModuleProxy::unregisterCSSAnimations(const jsi::Value &viewTag) {
-  cssAnimationsRegistry_->lock();
+  auto lock = cssAnimationsRegistry_->lock();
   cssAnimationsRegistry_->remove(viewTag.asNumber());
 }
 
@@ -526,7 +528,6 @@ void ReanimatedModuleProxy::registerCSSTransition(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeWrapper,
     const jsi::Value &transitionConfig) {
-  cssTransitionsRegistry_->lock();
   auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
 
   auto transition = std::make_shared<CSSTransition>(
@@ -534,7 +535,10 @@ void ReanimatedModuleProxy::registerCSSTransition(
       parseCSSTransitionConfig(rt, transitionConfig),
       viewStylesRepository_);
 
-  cssTransitionsRegistry_->add(transition);
+  {
+    auto lock = cssTransitionsRegistry_->lock();
+    cssTransitionsRegistry_->add(transition);
+  }
   maybeRunCSSLoop();
 }
 
@@ -542,7 +546,7 @@ void ReanimatedModuleProxy::updateCSSTransition(
     jsi::Runtime &rt,
     const jsi::Value &viewTag,
     const jsi::Value &configUpdates) {
-  cssTransitionsRegistry_->lock();
+  auto lock = cssTransitionsRegistry_->lock();
   cssTransitionsRegistry_->updateSettings(
       viewTag.asNumber(), parsePartialCSSTransitionConfig(rt, configUpdates));
   maybeRunCSSLoop();
@@ -551,7 +555,7 @@ void ReanimatedModuleProxy::updateCSSTransition(
 void ReanimatedModuleProxy::unregisterCSSTransition(
     jsi::Runtime &rt,
     const jsi::Value &viewTag) {
-  cssTransitionsRegistry_->lock();
+  auto lock = cssTransitionsRegistry_->lock();
   cssTransitionsRegistry_->remove(viewTag.asNumber());
 }
 
@@ -697,20 +701,23 @@ void ReanimatedModuleProxy::performOperations() {
 
     if (shouldUpdateCssAnimations_) {
       currentCssTimestamp_ = getAnimationTimestamp_();
-      cssAnimationsRegistry_->lock();
+      auto lock = cssTransitionsRegistry_->lock();
       // Update CSS transitions and flush updates
       cssTransitionsRegistry_->update(currentCssTimestamp_);
-      cssTransitionsRegistry_->flushUpdates(updatesBatch, false);
+      cssTransitionsRegistry_->flushUpdates(updatesBatch);
     }
 
-    // Flush all animated props updates
-    animatedPropsRegistry_->flushUpdates(updatesBatch, true);
+    {
+      auto lock = animatedPropsRegistry_->lock();
+      // Flush all animated props updates
+      animatedPropsRegistry_->flushUpdates(updatesBatch);
+    }
 
     if (shouldUpdateCssAnimations_) {
-      cssTransitionsRegistry_->lock();
+      auto lock = cssAnimationsRegistry_->lock();
       // Update CSS animations and flush updates
       cssAnimationsRegistry_->update(currentCssTimestamp_);
-      cssAnimationsRegistry_->flushUpdates(updatesBatch, true);
+      cssAnimationsRegistry_->flushUpdates(updatesBatch);
     }
 
     shouldUpdateCssAnimations_ = false;
@@ -780,7 +787,9 @@ void ReanimatedModuleProxy::commitUpdates(
     for (auto const &[family, props] : propsMap) {
       const auto surfaceId = family->getSurfaceId();
       auto &propsVector = propsMapBySurface[surfaceId][family];
-      propsVector.insert(propsVector.end(), props.begin(), props.end());
+      for (const auto &prop : props) {
+        propsVector.emplace_back(prop);
+      }
     }
   } else {
     for (auto const &[shadowNode, props] : updatesBatch) {
@@ -834,7 +843,19 @@ void ReanimatedModuleProxy::dispatchCommand(
   ShadowNode::Shared shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
   std::string commandName = stringFromValue(rt, commandNameValue);
   folly::dynamic args = commandArgsFromValue(rt, argsValue);
-  uiManager_->dispatchCommand(shadowNode, commandName, args);
+  const auto &scheduler = static_cast<Scheduler *>(uiManager_->getDelegate());
+
+  if (!scheduler) {
+    return;
+  }
+
+  const auto &schedulerDelegate = scheduler->getDelegate();
+
+  if (schedulerDelegate) {
+    const auto shadowView = ShadowView(*shadowNode);
+    schedulerDelegate->schedulerDidDispatchCommand(
+        shadowView, commandName, args);
+  }
 }
 
 jsi::String ReanimatedModuleProxy::obtainProp(

package/README.md

@@ -10,14 +10,16 @@
 [![NPM Worklets publish [Nightly]](https://github.com/software-mansion/react-native-reanimated/actions/workflows/npm-worklets-publish-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/npm-worklets-publish-nightly.yml)
 [![Lint clang-tidy [Nightly]](https://github.com/software-mansion/react-native-reanimated/actions/workflows/lint-clang-tidy-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/lint-clang-tidy-nightly.yml)
 [![Reanimated compatibility check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-compatibility-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-compatibility-check-nightly.yml)
-[![Static framework Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/static-framework-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/static-framework-reanimated-build-check-nightly.yml)
+[![Use frameworks Reanimated build check [Nightly]](https://github.com/software-mansion/react-native-reanimated/actions/workflows/use-frameworks-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/use-frameworks-reanimated-build-check-nightly.yml)
 [![React Native nightly Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/react-native-nightly-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/react-native-nightly-reanimated-build-check-nightly.yml)
 [![Expo DevClient build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/expo-devclient-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/expo-devclient-build-check-nightly.yml)
 [![Reanimated TypeScript compatibility test](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-typescript-compatibility-test-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-typescript-compatibility-test-nightly.yml)
-[![V8 Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/V8-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/V8-reanimated-build-check-nightly.yml)
 [![Windows hosted app Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/windows-hosted-app-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/windows-hosted-app-reanimated-build-check-nightly.yml)
 [![URL validation](https://github.com/software-mansion/react-native-reanimated/actions/workflows/url-validation-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/url-validation-nightly.yml)
 
+<!-- TODO: Restore badge once V8 is supported. -->
+<!-- [![V8 Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/V8-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/V8-reanimated-build-check-nightly.yml) -->
+
 ## Installation
 
 Check out the [installation](https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/getting-started/#installation) section of our docs for the detailed installation instructions.