@react-native-ohos/react-native-reanimated 3.18.1-rc.1

package/harmony/reanimated/BuildProfile.ets

@@ -0,0 +1,17 @@
+/**
+ * Use these variables when you tailor your ArkTS code. They must be of the const type.
+ */
+export const HAR_VERSION = '3.18.1-rc.1';
+export const BUILD_MODE_NAME = 'debug';
+export const DEBUG = true;
+export const TARGET_NAME = 'default';
+
+/**
+ * BuildProfile Class is used only for compatibility purposes.
+ */
+export default class BuildProfile { 
+	static readonly HAR_VERSION = HAR_VERSION;
+	static readonly BUILD_MODE_NAME = BUILD_MODE_NAME;
+	static readonly DEBUG = DEBUG;
+	static readonly TARGET_NAME = TARGET_NAME;
+}

package/harmony/reanimated/build-profile.json5

@@ -0,0 +1,12 @@
+{
+  "apiType": 'stageMode',
+  "targets": [
+    {
+      "name": "default",
+      "runtimeOS": "HarmonyOS"
+    },
+    {
+      "name": "ohosTest",
+    }
+  ]
+}

package/harmony/reanimated/hvigorfile.ts

@@ -0,0 +1,5 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+export { harTasks } from '@ohos/hvigor-ohos-plugin';

package/harmony/reanimated/index.ets

@@ -0,0 +1,5 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+export * from './ts'

package/harmony/reanimated/oh-package.json5

@@ -0,0 +1,12 @@
+{
+  name: '@react-native-ohos/react-native-reanimated',
+  version: '3.18.1-rc.1',
+  description: "",
+  type: 'module',
+  main: 'index.ets',
+  author: '',
+  license: '',
+  dependencies: {
+    "@rnoh/react-native-openharmony": "file:../react_native_openharmony.har",
+  },
+}

package/harmony/reanimated/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,72 @@
+cmake_minimum_required(VERSION 3.4.1)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+add_compile_definitions(REANIMATED_VERSION=3.18.0)
+add_compile_definitions(JS_RUNTIME_HERMES=1)
+add_compile_definitions(RCT_NEW_ARCH_ENABLED=1)
+add_compile_definitions(HERMES_ENABLE_DEBUGGER=1)
+
+set(REANIMATED_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Common")
+set(PATCHES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/patches")
+
+file(GLOB rnoh_reanimated_SRC CONFIGURE_DEPENDS *.cpp)
+
+add_library(rnoh_reanimated SHARED ${rnoh_reanimated_SRC})
+
+target_include_directories(
+  rnoh_reanimated
+  PRIVATE
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/AnimatedSensor"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/Fabric"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/hidden_headers"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/LayoutAnimations"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/NativeModules"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/ReanimatedRuntime"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Registries"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/SharedItems"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/Tools"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools"
+  "${REANIMATED_SRC_DIR}/cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/WorkletRuntime"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/RuntimeDecorators"
+)
+target_sources(rnoh_reanimated 
+  PRIVATE 
+  # BEGIN: patches
+  "${PATCHES_DIR}/Fabric/ShadowTreeCloner.cpp"
+  "${PATCHES_DIR}/NativeModules/ReanimatedModuleProxy.cpp"
+  "${PATCHES_DIR}/AnimatedSensor/AnimatedSensorModule.cpp"
+  # END: patches
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/Fabric/PropsRegistry.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/Fabric/ReanimatedCommitHook.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/Fabric/ReanimatedMountHook.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/LayoutAnimations/LayoutAnimationsManager.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/NativeModules/ReanimatedModuleProxySpec.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/RuntimeDecorators/RNRuntimeDecorator.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/WorkletRuntime/ReanimatedHermesRuntime.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/WorkletRuntime/ReanimatedRuntime.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/WorkletRuntime/WorkletRuntime.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Registries/WorkletRuntimeRegistry.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Registries/EventHandlerRegistry.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/SharedItems/Shareables.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools/AsyncQueue.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/Tools/FeaturesConfig.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools/JSISerializer.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools/JSLogger.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools/JSScheduler.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools/ReanimatedJSIUtils.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools/ReanimatedVersion.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/reanimated/RuntimeDecorators/UIRuntimeDecorator.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools/UIScheduler.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/Tools/WorkletEventHandler.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/NativeModules/WorkletsModuleProxy.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/NativeModules/WorkletsModuleProxySpec.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/WorkletRuntime/RNRuntimeWorkletDecorator.cpp"
+  "${REANIMATED_SRC_DIR}/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.cpp"
+  )
+
+target_include_directories(rnoh_reanimated PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(rnoh_reanimated PUBLIC rnoh)
+

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/AnimatedSensor/AnimatedSensorModule.cpp

@@ -0,0 +1,86 @@
+#include <reanimated/AnimatedSensor/AnimatedSensorModule.h>
+
+#include <utility>
+
+namespace reanimated {
+
+AnimatedSensorModule::AnimatedSensorModule(
+    const PlatformDepMethodsHolder &platformDepMethodsHolder)
+    : platformRegisterSensorFunction_(platformDepMethodsHolder.registerSensor),
+      platformUnregisterSensorFunction_(
+          platformDepMethodsHolder.unregisterSensor) {}
+
+AnimatedSensorModule::~AnimatedSensorModule() {
+  assert(sensorsIds_.empty());
+}
+
+jsi::Value AnimatedSensorModule::registerSensor(
+    jsi::Runtime &rt,
+    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+    const jsi::Value &sensorTypeValue,
+    const jsi::Value &interval,
+    const jsi::Value &iosReferenceFrame,
+    const jsi::Value &sensorDataHandler) {
+  SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
+
+  auto shareableHandler = extractShareableOrThrow<ShareableWorklet>(
+      rt,
+      sensorDataHandler,
+      "[Reanimated] Sensor event handler must be a worklet.");
+
+  int sensorId = platformRegisterSensorFunction_(
+      sensorType,
+      interval.asNumber(),
+      iosReferenceFrame.asNumber(),
+      [sensorType,
+       shareableHandler,
+       weakUiWorkletRuntime = std::weak_ptr<WorkletRuntime>(uiWorkletRuntime)](
+          double newValues[], int orientationDegrees) {
+        auto uiWorkletRuntime = weakUiWorkletRuntime.lock();
+        if (uiWorkletRuntime == nullptr) {
+          return;
+        }
+
+        jsi::Runtime &uiRuntime = uiWorkletRuntime->getJSIRuntime();
+        jsi::Object value(uiRuntime);
+        if (sensorType == SensorType::ROTATION_VECTOR) {
+          // TODO: timestamp should be provided by the platform implementation
+          // such that the native side has a chance of providing a true event
+          // timestamp
+          value.setProperty(uiRuntime, "qx", newValues[0]);
+          value.setProperty(uiRuntime, "qy", newValues[1]);
+          value.setProperty(uiRuntime, "qz", newValues[2]);
+          value.setProperty(uiRuntime, "qw", newValues[3]);
+          value.setProperty(uiRuntime, "yaw", newValues[4]);
+          value.setProperty(uiRuntime, "pitch", newValues[5]);
+          value.setProperty(uiRuntime, "roll", newValues[6]);
+        } else {
+          value.setProperty(uiRuntime, "x", newValues[0]);
+          value.setProperty(uiRuntime, "y", newValues[1]);
+          value.setProperty(uiRuntime, "z", newValues[2]);
+        }
+        value.setProperty(
+            uiRuntime, "interfaceOrientation", orientationDegrees);
+
+        uiWorkletRuntime->runGuarded(shareableHandler, value);
+      });
+  if (sensorId != -1) {
+    sensorsIds_.insert(sensorId);
+  }
+  return jsi::Value(sensorId);
+}
+
+void AnimatedSensorModule::unregisterSensor(const jsi::Value &sensorId) {
+  // It is called during sensor hook unmounting
+  sensorsIds_.erase(sensorId.getNumber());
+  platformUnregisterSensorFunction_(sensorId.asNumber());
+}
+
+void AnimatedSensorModule::unregisterAllSensors() {
+  for (auto sensorId : sensorsIds_) {
+    platformUnregisterSensorFunction_(sensorId);
+  }
+  sensorsIds_.clear();
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/AnimatedSensor/AnimatedSensorModule.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <unordered_set>
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace worklets;
+
+enum SensorType {
+  ACCELEROMETER = 1,
+  GYROSCOPE = 2,
+  GRAVITY = 3,
+  MAGNETIC_FIELD = 4,
+  ROTATION_VECTOR = 5,
+};
+
+class AnimatedSensorModule {
+  std::unordered_set<int> sensorsIds_;
+  RegisterSensorFunction platformRegisterSensorFunction_;
+  UnregisterSensorFunction platformUnregisterSensorFunction_;
+
+ public:
+  AnimatedSensorModule(
+      const PlatformDepMethodsHolder &platformDepMethodsHolder);
+  ~AnimatedSensorModule();
+
+  jsi::Value registerSensor(
+      jsi::Runtime &rt,
+      const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+      const jsi::Value &sensorType,
+      const jsi::Value &interval,
+      const jsi::Value &iosReferenceFrame,
+      const jsi::Value &sensorDataContainer);
+  void unregisterSensor(const jsi::Value &sensorId);
+  void unregisterAllSensors();
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/PropsRegistry.cpp

@@ -0,0 +1,68 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/Fabric/PropsRegistry.h>
+
+namespace reanimated {
+
+std::lock_guard<std::mutex> PropsRegistry::createLock() const {
+  return std::lock_guard<std::mutex>(mutex_);
+}
+
+void PropsRegistry::update(
+    const ShadowNode::Shared &shadowNode,
+    folly::dynamic &&props) {
+  const auto tag = shadowNode->getTag();
+  const auto it = map_.find(tag);
+  if (it == map_.cend()) {
+    // we need to store ShadowNode because `ShadowNode::getFamily`
+    // returns `ShadowNodeFamily const &` which is non-owning
+    map_[tag] = std::make_pair(shadowNode, props);
+  } else {
+    // no need to update `.first` because ShadowNode's family never changes
+    // merge new props with old props
+    it->second.second.update(props);
+  }
+}
+
+void PropsRegistry::for_each(std::function<void(
+                                 const ShadowNodeFamily &family,
+                                 const folly::dynamic &props)> callback) const {
+  for (const auto &[_, value] : map_) {
+    callback(value.first->getFamily(), value.second);
+  }
+}
+
+void PropsRegistry::markNodeAsRemovable(const ShadowNode::Shared &shadowNode) {
+  removableShadowNodes_[shadowNode->getTag()] = shadowNode;
+}
+
+void PropsRegistry::unmarkNodeAsRemovable(Tag viewTag) {
+  removableShadowNodes_.erase(viewTag);
+}
+
+void PropsRegistry::handleNodeRemovals(const RootShadowNode &rootShadowNode) {
+  for (auto it = removableShadowNodes_.begin();
+       it != removableShadowNodes_.end();) {
+    const auto &shadowNode = it->second;
+    const auto &family = shadowNode->getFamily();
+    const auto &ancestors = family.getAncestors(rootShadowNode);
+
+    // Skip if the node hasn't been removed
+    if (!ancestors.empty()) {
+      ++it;
+      continue;
+    }
+
+    const auto tag = shadowNode->getTag();
+    map_.erase(tag);
+    it = removableShadowNodes_.erase(it);
+  }
+}
+
+void PropsRegistry::remove(const Tag tag) {
+  map_.erase(tag);
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/PropsRegistry.h

@@ -0,0 +1,68 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/components/root/RootShadowNode.h>
+#include <react/renderer/core/ShadowNode.h>
+
+#include <unordered_map>
+#include <utility>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class PropsRegistry {
+ public:
+  std::lock_guard<std::mutex> createLock() const;
+  // returns a lock you need to hold when calling any of the methods below
+
+  void update(const ShadowNode::Shared &shadowNode, folly::dynamic &&props);
+
+  void for_each(std::function<void(
+                    const ShadowNodeFamily &family,
+                    const folly::dynamic &props)> callback) const;
+
+  void remove(const Tag tag);
+
+  void pauseReanimatedCommits() {
+    isPaused_ = true;
+  }
+
+  bool shouldReanimatedSkipCommit() {
+    return isPaused_;
+  }
+
+  void unpauseReanimatedCommits() {
+    isPaused_ = false;
+  }
+
+  void pleaseCommitAfterPause() {
+    shouldCommitAfterPause_ = true;
+  }
+
+  bool shouldCommitAfterPause() {
+    return shouldCommitAfterPause_.exchange(false);
+  }
+
+  bool isEmpty() {
+    return map_.empty();
+  }
+
+  void markNodeAsRemovable(const ShadowNode::Shared &shadowNode);
+  void unmarkNodeAsRemovable(Tag viewTag);
+  void handleNodeRemovals(const RootShadowNode &rootShadowNode);
+
+ private:
+  std::unordered_map<Tag, std::pair<ShadowNode::Shared, folly::dynamic>> map_;
+  std::unordered_map<Tag, ShadowNode::Shared> removableShadowNodes_;
+
+  mutable std::mutex mutex_; // Protects `map_`.
+
+  std::atomic<bool> isPaused_;
+  std::atomic<bool> shouldCommitAfterPause_;
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.cpp

@@ -0,0 +1,101 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/Fabric/ReanimatedCommitHook.h>
+#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+
+#include <react/renderer/core/ComponentDescriptor.h>
+
+#include <unordered_map>
+#include <vector>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+ReanimatedCommitHook::ReanimatedCommitHook(
+    const std::shared_ptr<PropsRegistry> &propsRegistry,
+    const std::shared_ptr<UIManager> &uiManager,
+    const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy)
+    : propsRegistry_(propsRegistry),
+      uiManager_(uiManager),
+      layoutAnimationsProxy_(layoutAnimationsProxy) {
+  uiManager_->registerCommitHook(*this);
+}
+
+ReanimatedCommitHook::~ReanimatedCommitHook() noexcept {
+  uiManager_->unregisterCommitHook(*this);
+}
+
+void ReanimatedCommitHook::maybeInitializeLayoutAnimations(
+    SurfaceId surfaceId) {
+  auto lock = std::unique_lock<std::mutex>(mutex_);
+  if (surfaceId > currentMaxSurfaceId_) {
+    // when a new surfaceId is observed we call setMountingOverrideDelegate
+    // for all yet unseen surfaces
+    uiManager_->getShadowTreeRegistry().enumerate(
+        [strongThis = shared_from_this()](
+            const ShadowTree &shadowTree, bool &stop) {
+          // Executed synchronously.
+          if (shadowTree.getSurfaceId() <= strongThis->currentMaxSurfaceId_) {
+            // the set function actually adds our delegate to a list, so we
+            // shouldn't invoke it twice for the same surface
+            return;
+          }
+          shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
+              strongThis->layoutAnimationsProxy_);
+        });
+    currentMaxSurfaceId_ = surfaceId;
+  }
+}
+
+RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
+    ShadowTree const &,
+    RootShadowNode::Shared const &,
+    RootShadowNode::Unshared const &newRootShadowNode) noexcept {
+  maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
+
+  auto reaShadowNode =
+      std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
+          newRootShadowNode);
+
+  if (reaShadowNode->hasReanimatedCommitTrait()) {
+    // ShadowTree commited by Reanimated, no need to apply updates from
+    // PropsRegistry
+    reaShadowNode->unsetReanimatedCommitTrait();
+    reaShadowNode->setReanimatedMountTrait();
+    return newRootShadowNode;
+  }
+
+  // ShadowTree not commited by Reanimated, apply updates from PropsRegistry
+  reaShadowNode->unsetReanimatedMountTrait();
+  RootShadowNode::Unshared rootNode = newRootShadowNode;
+  PropsMap propsMap;
+
+  {
+    auto lock = propsRegistry_->createLock();
+
+    propsRegistry_->for_each(
+        [&](const ShadowNodeFamily &family, const folly::dynamic &props) {
+          propsMap[&family].emplace_back(props);
+        });
+
+    rootNode = cloneShadowTreeWithNewProps(*rootNode, propsMap);
+
+    // If the commit comes from React Native then pause commits from
+    // Reanimated since the ShadowTree to be committed by Reanimated may not
+    // include the new changes from React Native yet and all changes of animated
+    // props will be applied in ReanimatedCommitHook by iterating over
+    // PropsRegistry.
+    // This is very important, since if we didn't pause Reanimated commits,
+    // it could lead to RN commits being delayed until the animation is finished
+    // (very bad).
+    propsRegistry_->pauseReanimatedCommits();
+  }
+
+  return rootNode;
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.h

@@ -0,0 +1,51 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/Fabric/PropsRegistry.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
+
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+
+#include <memory>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+class ReanimatedCommitHook
+    : public UIManagerCommitHook,
+      public std::enable_shared_from_this<ReanimatedCommitHook> {
+ public:
+  ReanimatedCommitHook(
+      const std::shared_ptr<PropsRegistry> &propsRegistry,
+      const std::shared_ptr<UIManager> &uiManager,
+      const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy);
+
+  ~ReanimatedCommitHook() noexcept override;
+
+  void commitHookWasRegistered(UIManager const &) noexcept override {}
+
+  void commitHookWasUnregistered(UIManager const &) noexcept override {}
+
+  void maybeInitializeLayoutAnimations(SurfaceId surfaceId);
+
+  RootShadowNode::Unshared shadowTreeWillCommit(
+      ShadowTree const &shadowTree,
+      RootShadowNode::Shared const &oldRootShadowNode,
+      RootShadowNode::Unshared const &newRootShadowNode) noexcept override;
+
+ private:
+  std::shared_ptr<PropsRegistry> propsRegistry_;
+
+  std::shared_ptr<UIManager> uiManager_;
+
+  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
+
+  SurfaceId currentMaxSurfaceId_ = -1;
+
+  std::mutex mutex_; // Protects `currentMaxSurfaceId_`.
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitShadowNode.h

@@ -0,0 +1,49 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/core/ShadowNode.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+// We use this trait to mark that a commit was created by Reanimated.
+// Traits are copied when nodes are cloned, so this information
+// won't be lost unless someone explicitly overrides it.
+// We need this information to skip unnecessary updates in
+// the commit hook.
+// Currently RN traits go up to 10, so hopefully
+// the arbitrarily chosen numbers 27 and 28 will be safe :)
+
+// We have to use 2 traits, because we want to distinguish reanimated
+// commits both in the commit hook and mount hook. If we only had one trait
+// and didn't remove it in the commit hook, then any node that would clone
+// this node would also have our commit trait, rendering this trait useless.
+constexpr ShadowNodeTraits::Trait ReanimatedCommitTrait{1 << 27};
+constexpr ShadowNodeTraits::Trait ReanimatedMountTrait{1 << 28};
+
+class ReanimatedCommitShadowNode : public ShadowNode {
+ public:
+  inline void setReanimatedCommitTrait() {
+    traits_.set(ReanimatedCommitTrait);
+  }
+  inline void unsetReanimatedCommitTrait() {
+    traits_.unset(ReanimatedCommitTrait);
+  }
+  inline bool hasReanimatedCommitTrait() {
+    return traits_.check(ReanimatedCommitTrait);
+  }
+  inline void setReanimatedMountTrait() {
+    traits_.set(ReanimatedMountTrait);
+  }
+  inline void unsetReanimatedMountTrait() {
+    traits_.unset(ReanimatedMountTrait);
+  }
+  inline bool hasReanimatedMountTrait() {
+    return traits_.check(ReanimatedMountTrait);
+  }
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED