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

package/harmony/reanimated/src/main/cpp/PseudoSelectorManager.cpp

@@ -0,0 +1,140 @@
+// Copyright (c) 2026 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.
+
+#include "PseudoSelectorManager.h"
+
+namespace rnoh {
+
+using reanimated::PseudoSelector;
+
+PseudoSelectorManager::PseudoSelectorManager(AncestryProvider ancestryProvider)
+    : m_ancestryProvider(std::move(ancestryProvider)) {}
+
+void PseudoSelectorManager::attach(facebook::react::Tag tag, PseudoSelector selector,
+                                   SelectorStateCallback callback) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_entries[tag][selector] = Entry{std::move(callback), false};
+}
+
+void PseudoSelectorManager::detach(facebook::react::Tag tag, PseudoSelector selector) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    auto it = m_entries.find(tag);
+    if (it == m_entries.end()) {
+        return;
+    }
+    it->second.erase(selector);
+    if (it->second.empty()) {
+        m_entries.erase(it);
+    }
+}
+
+void PseudoSelectorManager::handleRawEvent(facebook::react::RawEvent const &rawEvent) {
+    const auto &type = rawEvent.type;
+    const bool isPointerEvent = type == "topPointerEnter" || type == "topPointerLeave";
+    const bool isTouchEvent = type == "topTouchStart" || type == "topTouchEnd" || type == "topTouchCancel";
+    const bool isFocusEvent = type == "topFocus" || type == "topBlur";
+    if (!isPointerEvent && !isTouchEvent && !isFocusEvent) {
+        return;
+    }
+
+    if (rawEvent.eventTarget == nullptr) {
+        return;
+    }
+    const auto tag = rawEvent.eventTarget->getTag();
+
+    if (type == "topPointerEnter") {
+        m_hoveredTags.insert(tag);
+    } else if (type == "topPointerLeave") {
+        m_hoveredTags.erase(tag);
+    } else if (type == "topTouchStart") {
+        if (m_pressedTouchCounts[tag]++ == 0) {
+            m_pressedChains[tag] = m_ancestryProvider ? m_ancestryProvider(tag)
+                                                      : std::vector<facebook::react::Tag>{tag};
+        }
+    } else if (type == "topTouchEnd" || type == "topTouchCancel") {
+        auto it = m_pressedTouchCounts.find(tag);
+        if (it != m_pressedTouchCounts.end() && --it->second == 0) {
+            m_pressedTouchCounts.erase(it);
+            m_pressedChains.erase(tag);
+        }
+    } else if (type == "topFocus") {
+        m_focusedTag = tag;
+        m_focusedChain.clear();
+        if (m_ancestryProvider) {
+            for (auto ancestor : m_ancestryProvider(tag)) {
+                m_focusedChain.insert(ancestor);
+            }
+        } else {
+            m_focusedChain.insert(tag);
+        }
+    } else { // topBlur
+        if (m_focusedTag.has_value() && *m_focusedTag == tag) {
+            m_focusedTag.reset();
+            m_focusedChain.clear();
+        }
+    }
+
+    recomputeAndNotify();
+}
+
+void PseudoSelectorManager::recomputeAndNotify() {
+    std::vector<std::pair<SelectorStateCallback, bool>> notifications;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (m_entries.empty()) {
+            return;
+        }
+        
+        std::unordered_set<facebook::react::Tag> pressedTags;
+        std::unordered_set<facebook::react::Tag> deepestActiveTags;
+        for (const auto &entry : m_pressedChains) {
+            bool deepestFound = false;
+            for (auto chainTag : entry.second) {
+                pressedTags.insert(chainTag);
+                if (!deepestFound) {
+                    auto tagIt = m_entries.find(chainTag);
+                    if (tagIt != m_entries.end() && tagIt->second.count(PseudoSelector::ActiveDeepest) > 0) {
+                        deepestActiveTags.insert(chainTag);
+                        deepestFound = true;
+                    }
+                }
+            }
+        }
+
+        for (auto &tagEntry : m_entries) {
+            const auto tag = tagEntry.first;
+            for (auto &selectorEntry : tagEntry.second) {
+                const auto selector = selectorEntry.first;
+                auto &entry = selectorEntry.second;
+                bool active = false;
+                switch (selector) {
+                    case PseudoSelector::Hover:
+                        active = m_hoveredTags.count(tag) > 0;
+                        break;
+                    case PseudoSelector::Active:
+                        active = pressedTags.count(tag) > 0;
+                        break;
+                    case PseudoSelector::ActiveDeepest:
+                        active = deepestActiveTags.count(tag) > 0;
+                        break;
+                    case PseudoSelector::Focus:
+                        active = m_focusedTag.has_value() && *m_focusedTag == tag;
+                        break;
+                    case PseudoSelector::FocusWithin:
+                        active = m_focusedChain.count(tag) > 0;
+                        break;
+                }
+                if (active != entry.lastReported) {
+                    entry.lastReported = active;
+                    notifications.emplace_back(entry.callback, active);
+                }
+            }
+        }
+    }
+    for (auto &notification : notifications) {
+        notification.first(notification.second);
+    }
+}
+
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/PseudoSelectorManager.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2026 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.
+
+#pragma once
+
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/core/RawEvent.h>
+#include <reanimated/PseudoStyles/PseudoSelector.h>
+
+#include <functional>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace rnoh {
+
+class PseudoSelectorManager {
+public:
+    using SelectorStateCallback = std::function<void(bool)>;
+    using AncestryProvider = std::function<std::vector<facebook::react::Tag>(facebook::react::Tag)>;
+
+    explicit PseudoSelectorManager(AncestryProvider ancestryProvider);
+
+    void attach(facebook::react::Tag tag, reanimated::PseudoSelector selector, SelectorStateCallback callback);
+    void detach(facebook::react::Tag tag, reanimated::PseudoSelector selector);
+    void handleRawEvent(facebook::react::RawEvent const &rawEvent);
+
+private:
+    struct Entry {
+        SelectorStateCallback callback;
+        bool lastReported = false;
+    };
+
+    void recomputeAndNotify();
+
+    AncestryProvider m_ancestryProvider;
+    
+    std::mutex m_mutex;
+    std::unordered_map<facebook::react::Tag, std::map<reanimated::PseudoSelector, Entry>> m_entries;
+    
+    std::unordered_set<facebook::react::Tag> m_hoveredTags;
+    std::unordered_map<facebook::react::Tag, size_t> m_pressedTouchCounts;
+    std::unordered_map<facebook::react::Tag, std::vector<facebook::react::Tag>> m_pressedChains;
+    std::optional<facebook::react::Tag> m_focusedTag;
+    std::unordered_set<facebook::react::Tag> m_focusedChain;
+};
+
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/REASharedTransitionBoundaryComponentInstance.cpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2026 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.
+
+#include "REASharedTransitionBoundaryComponentInstance.h"
+
+namespace rnoh {
+
+REASharedTransitionBoundaryComponentInstance::REASharedTransitionBoundaryComponentInstance(
+    Context context)
+    : CppComponentInstance(std::move(context)), m_customNode(m_arkUINodeCtx) {}
+
+void REASharedTransitionBoundaryComponentInstance::onChildInserted(
+    ComponentInstance::Shared const& childComponentInstance,
+    std::size_t index) {
+  CppComponentInstance::onChildInserted(childComponentInstance, index);
+  m_customNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+}
+
+void REASharedTransitionBoundaryComponentInstance::onChildRemoved(
+    ComponentInstance::Shared const& childComponentInstance) {
+  CppComponentInstance::onChildRemoved(childComponentInstance);
+  m_customNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+}
+
+CustomNode& REASharedTransitionBoundaryComponentInstance::getLocalRootArkUINode() {
+  return m_customNode;
+}
+
+void REASharedTransitionBoundaryComponentInstance::onLayoutChanged(
+    facebook::react::LayoutMetrics const& layoutMetrics) {
+  auto adjusted = layoutMetrics;
+  const auto scaleFactor =
+      layoutMetrics.pointScaleFactor > 0 ? layoutMetrics.pointScaleFactor : 1.f;
+  const auto minSize = 1.f / scaleFactor; // rounds to >= 1px in setLayoutRect
+  if (adjusted.frame.size.width < minSize) {
+    adjusted.frame.size.width = minSize;
+  }
+  if (adjusted.frame.size.height < minSize) {
+    adjusted.frame.size.height = minSize;
+  }
+  CppComponentInstance::onLayoutChanged(adjusted);
+}
+
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/REASharedTransitionBoundaryComponentInstance.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2026 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.
+
+#pragma once
+
+#include "Common/NativeView/react/renderer/components/rnreanimated/REASharedTransitionBoundaryShadowNode.h"
+#include "RNOH/CppComponentInstance.h"
+#include "RNOH/arkui/CustomNode.h"
+
+namespace rnoh {
+
+class REASharedTransitionBoundaryComponentInstance
+    : public CppComponentInstance<facebook::react::REASharedTransitionBoundaryShadowNode> {
+ private:
+  CustomNode m_customNode;
+
+ public:
+  explicit REASharedTransitionBoundaryComponentInstance(Context context);
+
+  void onChildInserted(
+      ComponentInstance::Shared const& childComponentInstance,
+      std::size_t index) override;
+
+  void onChildRemoved(
+      ComponentInstance::Shared const& childComponentInstance) override;
+
+  CustomNode& getLocalRootArkUINode() override;
+
+  void onLayoutChanged(facebook::react::LayoutMetrics const& layoutMetrics) override;
+};
+
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/REASharedTransitionBoundaryJSIBinder.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2026 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.
+
+#pragma once
+
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+
+class REASharedTransitionBoundaryJSIBinder : public ViewComponentJSIBinder {
+ protected:
+  facebook::jsi::Object createNativeProps(facebook::jsi::Runtime& rt) override {
+    auto nativeProps = ViewComponentJSIBinder::createNativeProps(rt);
+    nativeProps.setProperty(rt, "isActive", true);
+    return nativeProps;
+  }
+};
+
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/ReanimatedModule.cpp

@@ -1,19 +1,20 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 
 #include "RNOH/ArkTSTurboModule.h"
 #include "RNOH/RNInstance.h"
 #include "ReanimatedModule.h"
+#include "PseudoSelectorManager.h"
 #include "ReanimatedSensorContainer.h"
-#include "ReanimatedUIScheduler.h"
 #include "PlatformDepMethodsHolder.h"
 #include "WorkletRuntimeCollector.h"
 #include "RNRuntimeDecorator.h"
 #include "TransformParser.h"
 #include "RNOH/RNInstanceCAPI.h"
 #include "WorkletsModule.h"
-
+#include "ReanimatedNodesManager.h"
+#include "OHOSCSSPlatformTransitions.h"
 using namespace facebook;
 using namespace reanimated;
 using namespace worklets;
@@ -37,7 +38,7 @@ ReanimatedModule::ReanimatedModule(const ArkTSTurboModule::Context ctx, const st
 }
 
 ReanimatedModule::~ReanimatedModule() {
-    LOG(INFO) << "ReanimatedModule::~ReanimatedModule";
+    DLOG(INFO) << "ReanimatedModule::~ReanimatedModule";
     if (eventListener) {
         m_ctx.scheduler->removeEventListener(eventListener);
     }
@@ -45,16 +46,15 @@ ReanimatedModule::~ReanimatedModule() {
         keyboardEventDataUpdater_ = nullptr;
     }
     if (auto nativeReanimatedModule = weakNativeReanimatedModule_.lock()) {
-        nativeReanimatedModule->invalidate();
+        nativeReanimatedModule->cleanupSensors();
     }
 }
 
 void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
     if (!m_ctx.taskExecutor->isOnTaskThread(rnoh::TaskThread::JS)) {
-        DLOG(ERROR) << "react_worklets reanimated installTurboModule failed,because of current thread is not js;";
+        DLOG(ERROR) << "[reanimated] reanimated installTurboModule failed,because of current thread is not js;";
         return;
     }
-    
     auto runMainThreadFuc = [weakExecutor = std::weak_ptr(m_ctx.taskExecutor)](TaskExecutor::Task &&task) {
         if (auto taskExecutor = weakExecutor.lock()) {
             taskExecutor->runTask(TaskThread::MAIN, std::move(task));
@@ -115,11 +115,13 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
             self->keyboardEventDataUpdater_ = std::move(keyboardEventDataUpdater);
             auto weakExecutor = std::weak_ptr(self->m_ctx.taskExecutor);
             if (auto taskExecutor = weakExecutor.lock()) {
-                taskExecutor->runTask(TaskThread::MAIN, [ctx = self->m_ctx, isStatusBarTranslucent]() {
+                taskExecutor->runTask(TaskThread::MAIN, [ctx = self->m_ctx, isStatusBarTranslucent, isNavigationBarTranslucent]() {
                     ArkJS arkJs(ctx.env);
-                    // arkJs.createBoolean(isStatusBarTranslucent);
                     auto napiTurboModuleObject = arkJs.getObject(ctx.arkTSTurboModuleInstanceRef);
-                    napiTurboModuleObject.call("subscribeKeyBordListeners", {});
+                    napiTurboModuleObject.call("subscribeKeyBordListeners", {
+                        arkJs.createBoolean(isStatusBarTranslucent),
+                        arkJs.createBoolean(isNavigationBarTranslucent),
+                    });
                 });
             }
             return 0;
@@ -151,6 +153,65 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
         napiTurboModuleObject.call("setGestureHandlerState", {napiTag, napiState});
     };
 
+    auto pseudoSelectorManager = std::make_shared<PseudoSelectorManager>(
+        [weakInstance = std::weak_ptr(m_ctx.instance)](facebook::react::Tag tag) {
+            std::vector<facebook::react::Tag> chain;
+            auto instance = weakInstance.lock();
+            auto instanceCapi = std::dynamic_pointer_cast<RNInstanceCAPI>(instance);
+            if (!instanceCapi) {
+                chain.push_back(tag);
+                return chain;
+            }
+            auto componentInstance = instanceCapi->findComponentInstanceByTag(tag);
+            while (componentInstance != nullptr && chain.size() < 512) {
+                chain.push_back(componentInstance->getTag());
+                componentInstance = componentInstance->getParent().lock();
+            }
+            if (chain.empty()) {
+                chain.push_back(tag);
+            }
+            return chain;
+        });
+    pseudoSelectorManager_ = pseudoSelectorManager;
+    auto attachPseudoSelector = [pseudoSelectorManager](Tag tag, PseudoSelector pseudoSelector,
+                                                        std::function<void(bool)> callback) {
+        pseudoSelectorManager->attach(tag, pseudoSelector, std::move(callback));
+    };
+    auto detachPseudoSelector = [pseudoSelectorManager](Tag tag, PseudoSelector pseudoSelector) {
+        pseudoSelectorManager->detach(tag, pseudoSelector);
+    };
+
+    // CSS transition routing backend (IOS_CSS_CORE_ANIMATION flag)
+    auto cssPlatformTransitions = std::make_shared<css::OHOSCSSPlatformTransitions>(
+        m_ctx.instance, std::weak_ptr(m_ctx.taskExecutor));
+    auto cssCanRouteProperty = [](const std::string &propertyName, const css::EasingConfig &easing) {
+        return css::canRouteCSSProperty(propertyName, easing);
+    };
+    auto cssApplyTransitionJSI = [cssPlatformTransitions](
+                                     jsi::Runtime &rt,
+                                     Tag viewTag,
+                                     const std::string &propertyName,
+                                     const jsi::Value &fromValue,
+                                     const jsi::Value &toValue,
+                                     const css::CSSTransitionPropertySettings &settings,
+                                     double timestamp) {
+        return cssPlatformTransitions->applyTransitionForTag(
+            rt, viewTag, propertyName, fromValue, toValue, settings, timestamp);
+    };
+    auto cssApplyTransitionDynamic = [cssPlatformTransitions](
+                                         Tag viewTag,
+                                         const std::string &propertyName,
+                                         const folly::dynamic &fromValue,
+                                         const folly::dynamic &toValue,
+                                         double timestamp) {
+        return cssPlatformTransitions->applyDynamicTransitionForTag(
+            viewTag, propertyName, fromValue, toValue, timestamp);
+    };
+    auto cssRemoveTransition = [cssPlatformTransitions](
+                                   Tag viewTag, const std::string &propertyName) {
+        cssPlatformTransitions->removeTransitionForTag(viewTag, propertyName);
+    };
+
     PlatformDepMethodsHolder platformDepMethodsHolder = {
         requestRender,
         synchronouslyUpdateUIPropsFunction,
@@ -161,8 +222,27 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
         subscribeForKeyboardEventsFunction,
         unsubscribeFromKeyboardEventsFunction,
         maybeFlushUIUpdatesQueueFunction,
+        attachPseudoSelector,
+        detachPseudoSelector,
+        cssCanRouteProperty,
+        cssApplyTransitionJSI,
+        cssApplyTransitionDynamic,
+        cssRemoveTransition,
     };
-    auto isReducedMotion = false; // ANIMATOR_DURATION_SCALE
+    bool isReducedMotion = false; // ANIMATOR_DURATION_SCALE
+    m_ctx.taskExecutor->runSyncTask(TaskThread::MAIN,
+        [ctx = m_ctx, &isReducedMotion]() {
+            if (!ctx.arkTSTurboModuleInstanceRef) {
+                return;
+            }
+            ArkJS arkJs(ctx.env);
+            auto napiTurboModuleObject =
+                arkJs.getObject(ctx.arkTSTurboModuleInstanceRef);
+            auto napiResult =
+                napiTurboModuleObject.call("isReducedMotionEnabled", {});
+            isReducedMotion = arkJs.getBoolean(napiResult);
+        });
+    
     auto workletsModule = [weakSelf = weak_from_this()]() -> std::shared_ptr<WorkletsModule> {
         auto self = weakSelf.lock();
         if (!self) {
@@ -174,28 +254,43 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
         }
         return instance->getTurboModule<WorkletsModule>("WorkletsModule");
     };
+    auto workletsModuleInstance = workletsModule();
+    if (workletsModuleInstance == nullptr) {
+        DLOG(ERROR) << "[reanimated] WorkletsModule not found; install worklets before reanimated";
+        return;
+    }
+    auto workletsProxy = workletsModuleInstance->getWorkletsModuleProxy();
+    if (workletsProxy == nullptr) {
+        DLOG(ERROR) << "[reanimated] WorkletsModuleProxy not initialized yet "
+                      "(installTurboModule must run first)";
+        return;
+    }
+
     auto reanimatedModuleProxy = std::make_shared<ReanimatedModuleProxy>(
-        workletsModule()->getWorkletsModuleProxy(), rt, jsInvoker_, platformDepMethodsHolder, isReducedMotion);
+        workletsProxy->getUIWorkletRuntime(), workletsProxy->getUIScheduler(), rt, jsInvoker_,
+        platformDepMethodsHolder, isReducedMotion);
     reanimatedModuleProxy->init(platformDepMethodsHolder);
+    nativeReanimatedModule_ = reanimatedModuleProxy;
     weakNativeReanimatedModule_ = reanimatedModuleProxy;
 
     ReanimatedPerformOperations reanimatedPerformOperations = [weakNativeReanimatedModule =
                                                                    weakNativeReanimatedModule_]() {
         if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
-            nativeReanimatedModule->performOperations(false);
+            nativeReanimatedModule->performOperations();
         }
     };
     nodesManager->registerPerformOperations(reanimatedPerformOperations);
 
     WorkletRuntimeCollector::install(rt);
-    auto &uiRuntime = workletsModule()->getWorkletsModuleProxy()->getUIWorkletRuntime()->getJSIRuntime();
+    auto &uiRuntime = workletsProxy->getUIWorkletRuntime()->getJSIRuntime();
 
     RNRuntimeDecorator::decorate(rt, uiRuntime, reanimatedModuleProxy);
     injectDependencies(rt);
 
     eventListener = std::make_shared<facebook::react::EventListener>(
         [weakNativeReanimatedModule = weakNativeReanimatedModule_,
-         weakTaskExecutor = std::weak_ptr{m_ctx.taskExecutor}](facebook::react::RawEvent const &rawEvent) {
+         weakTaskExecutor = std::weak_ptr{m_ctx.taskExecutor},
+         pseudoSelectorManager](facebook::react::RawEvent const &rawEvent) {
             auto taskExecutor = weakTaskExecutor.lock();
             auto nativeReanimatedModule = weakNativeReanimatedModule.lock();
             if (!nativeReanimatedModule || !taskExecutor || !taskExecutor->isOnTaskThread(TaskThread::MAIN)) {
@@ -204,10 +299,8 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
 
             auto eventType = rawEvent.type;
             auto frameTime = getMillisSinceEpoch();
-
-            // React Native prefixes event names with "top". If the event name starts with "on", the result is that the
-            // event on the native side is prefixed with "topOn", while the JS side expects the event name to be without
-            // the "on" prefix.
+    
+            pseudoSelectorManager->handleRawEvent(rawEvent);
             if (eventType.rfind("topOn", 0) == 0) {
                 auto eventCopy = rawEvent;
                 eventCopy.type = "on" + eventType.substr(5);

package/harmony/reanimated/src/main/cpp/ReanimatedModule.h

@@ -1,12 +1,12 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 
 #pragma once
 
 #include "RNOH/ArkTSTurboModule.h"
+#include "PseudoSelectorManager.h"
 #include "ReanimatedModuleProxy.h"
-#include "ReanimatedNodesManager.h"
 
 namespace rnoh {
 class JSI_EXPORT ReanimatedModule : public std::enable_shared_from_this<ReanimatedModule>, public ArkTSTurboModule {
@@ -16,9 +16,11 @@ public:
     void installTurboModule(facebook::jsi::Runtime &rt);
     void callKeyBord(double height, int status);
 private:
+    std::shared_ptr<reanimated::ReanimatedModuleProxy> nativeReanimatedModule_;
     std::weak_ptr<reanimated::ReanimatedModuleProxy> weakNativeReanimatedModule_;
     void injectDependencies(facebook::jsi::Runtime &rt);
     std::shared_ptr<facebook::react::EventListener> eventListener;
     std::function<void(int keyboardState, int height)> keyboardEventDataUpdater_;
+    std::shared_ptr<PseudoSelectorManager> pseudoSelectorManager_;
 };
 } // namespace rnoh

package/harmony/reanimated/src/main/cpp/ReanimatedNodesManager.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 

package/harmony/reanimated/src/main/cpp/ReanimatedNodesManager.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 

package/harmony/reanimated/src/main/cpp/ReanimatedPackage.cpp

@@ -1,9 +1,13 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
 
 #include "ReanimatedPackage.h"
 #include "ReanimatedModule.h"
+#include "REASharedTransitionBoundaryComponentInstance.h"
+
+#include "REASharedTransitionBoundaryJSIBinder.h"
+#include "Common/NativeView/react/renderer/components/rnreanimated/REASharedTransitionBoundaryComponentDescriptor.h"
 
 using namespace rnoh;
 using namespace facebook;
@@ -42,3 +46,22 @@ std::vector<ArkTSMessageHandler::Shared> ReanimatedPackage::createArkTSMessageHa
 {
     return { std::make_shared<ReanimatedArkTsMessage>() };
 }
+
+std::vector<react::ComponentDescriptorProvider> ReanimatedPackage::createComponentDescriptorProviders()
+{
+    return { react::concreteComponentDescriptorProvider<
+        react::REASharedTransitionBoundaryComponentDescriptor>() };
+}
+
+ComponentInstance::Shared ReanimatedPackage::createComponentInstance(const ComponentInstance::Context& ctx)
+{
+    if (ctx.componentName == "REASharedTransitionBoundary") {
+        return std::make_shared<REASharedTransitionBoundaryComponentInstance>(ctx);
+    }
+    return Package::createComponentInstance(ctx);
+}
+
+ComponentJSIBinderByString ReanimatedPackage::createComponentJSIBinderByName()
+{
+    return { { "REASharedTransitionBoundary", std::make_shared<REASharedTransitionBoundaryJSIBinder>() } };
+}

package/harmony/reanimated/src/main/cpp/ReanimatedPackage.h

@@ -1,7 +1,6 @@
-// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Copyright (c) 2026 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.
-
 #include "RNOH/Package.h"
 
 namespace rnoh {
@@ -12,5 +11,11 @@ public:
     std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override;
 
     std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;
+
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override;
+
+    ComponentInstance::Shared createComponentInstance(const ComponentInstance::Context& ctx) override;
+
+    ComponentJSIBinderByString createComponentJSIBinderByName() override;
 };
 } // namespace rnoh