react-native-windows 0.80.1 → 0.81.0-preview.1

package/Microsoft.ReactNative/ReactRootView.cpp

@@ -5,14 +5,19 @@
 #include "ReactRootView.g.cpp"
 
 #include <QuirkSettings.h>
+#include <ReactHost/DebuggerNotifications.h>
 #include <ReactHost/MsoUtils.h>
+#include <UI.Text.h>
+#include <UI.Xaml.Controls.Primitives.h>
 #include <UI.Xaml.Input.h>
 #include <UI.Xaml.Media.Media3D.h>
 #include <Utils/Helpers.h>
 #include <dispatchQueue/dispatchQueue.h>
 #include <winrt/Windows.UI.Core.h>
+#include "InstanceManager.h"
 #include "ReactNativeHost.h"
 #include "ReactViewInstance.h"
+#include "Utils/KeyboardUtils.h"
 #include "XamlUtils.h"
 
 #include <winrt/Microsoft.UI.Xaml.Controls.h>
@@ -34,6 +39,7 @@ ReactRootView::ReactRootView() noexcept : m_uiQueue(Mso::DispatchQueue::GetCurre
   UpdatePerspective();
   Loaded([this](auto &&, auto &&) {
     ::Microsoft::ReactNative::SetCompositor(::Microsoft::ReactNative::GetCompositor(*this));
+    SetupDevToolsShortcut();
   });
 }
 
@@ -45,6 +51,20 @@ void ReactRootView::ReactNativeHost(ReactNative::ReactNativeHost const &value) n
   if (m_reactNativeHost != value) {
     ReactViewHost(nullptr);
     m_reactNativeHost = value;
+    const auto weakThis = this->get_weak();
+    ::Microsoft::ReactNative::DebuggerNotifications::SubscribeShowDebuggerPausedOverlay(
+        m_reactNativeHost.InstanceSettings().Notifications(),
+        m_reactNativeHost.InstanceSettings().UIDispatcher(),
+        [weakThis](std::string message, std::function<void()> onResume) {
+          if (auto strongThis = weakThis.get()) {
+            strongThis->ShowDebuggerPausedOverlay(message, onResume);
+          }
+        },
+        [weakThis]() {
+          if (auto strongThis = weakThis.get()) {
+            strongThis->HideDebuggerPausedOverlay();
+          }
+        });
     ReloadView();
   }
 }
@@ -283,6 +303,65 @@ void ReactRootView::EnsureLoadingUI() noexcept {
   }
 }
 
+void ReactRootView::HideDebuggerPausedOverlay() noexcept {
+  m_isDebuggerPausedOverlayOpen = false;
+  if (m_debuggerPausedFlyout) {
+    m_debuggerPausedFlyout.Hide();
+    m_debuggerPausedFlyout = nullptr;
+  }
+}
+
+void ReactRootView::ShowDebuggerPausedOverlay(
+    const std::string &message,
+    const std::function<void()> &onResume) noexcept {
+  // Initialize content
+  const xaml::Controls::Grid contentGrid;
+  xaml::Controls::ColumnDefinition messageColumnDefinition;
+  xaml::Controls::ColumnDefinition buttonColumnDefinition;
+  messageColumnDefinition.MinWidth(60);
+  buttonColumnDefinition.MinWidth(36);
+  contentGrid.ColumnDefinitions().Append(messageColumnDefinition);
+  contentGrid.ColumnDefinitions().Append(buttonColumnDefinition);
+  xaml::Controls::TextBlock messageBlock;
+  messageBlock.Text(winrt::to_hstring(message));
+  messageBlock.FontWeight(winrt::Windows::UI::Text::FontWeights::SemiBold());
+  xaml::Controls::FontIcon resumeGlyph;
+  resumeGlyph.FontFamily(xaml::Media::FontFamily(L"Segoe MDL2 Assets"));
+  resumeGlyph.Foreground(xaml::Media::SolidColorBrush(winrt::Colors::Green()));
+  resumeGlyph.Glyph(L"\uF5B0");
+  resumeGlyph.HorizontalAlignment(xaml::HorizontalAlignment::Right);
+  resumeGlyph.PointerReleased([onResume](auto &&...) { onResume(); });
+  xaml::Controls::Grid::SetColumn(resumeGlyph, 1);
+  contentGrid.Children().Append(messageBlock);
+  contentGrid.Children().Append(resumeGlyph);
+
+  // Configure flyout
+  m_isDebuggerPausedOverlayOpen = true;
+  xaml::Style flyoutStyle(
+      {XAML_NAMESPACE_STR L".Controls.FlyoutPresenter", winrt::Windows::UI::Xaml::Interop::TypeKind::Metadata});
+  flyoutStyle.Setters().Append(winrt::Setter(
+      xaml::Controls::Control::CornerRadiusProperty(), winrt::box_value(xaml::CornerRadius{12, 12, 12, 12})));
+  flyoutStyle.Setters().Append(winrt::Setter(
+      xaml::Controls::Control::BackgroundProperty(),
+      winrt::box_value(xaml::Media::SolidColorBrush{FromArgb(255, 255, 255, 193)})));
+  flyoutStyle.Setters().Append(
+      winrt::Setter(xaml::FrameworkElement::MarginProperty(), winrt::box_value(xaml::Thickness{0, 12, 0, 0})));
+  m_debuggerPausedFlyout = xaml::Controls::Flyout{};
+  m_debuggerPausedFlyout.FlyoutPresenterStyle(flyoutStyle);
+  m_debuggerPausedFlyout.LightDismissOverlayMode(xaml::Controls::LightDismissOverlayMode::On);
+  m_debuggerPausedFlyout.Content(contentGrid);
+
+  // Disable light dismiss
+  m_debuggerPausedFlyout.Closing([weakThis = this->get_weak()](auto &&, const auto &args) {
+    if (auto strongThis = weakThis.get()) {
+      args.Cancel(strongThis->m_isDebuggerPausedOverlayOpen);
+    }
+  });
+
+  // Show flyout
+  m_debuggerPausedFlyout.ShowAt(*this);
+}
+
 void ReactRootView::ShowInstanceLoaded() noexcept {
   if (m_xamlRootView) {
     ClearLoadingUI();
@@ -481,4 +560,33 @@ void ReactRootView::RemoveChildAt(uint32_t index) {
   Children().RemoveAt(RNIndexToXamlIndex(index));
 }
 
+bool IsCtrlShiftI(winrt::Windows::System::VirtualKey key) noexcept {
+  return (
+      key == winrt::Windows::System::VirtualKey::I &&
+      ::Microsoft::ReactNative::IsModifiedKeyPressed(
+          winrt::CoreWindow::GetForCurrentThread(), winrt::Windows::System::VirtualKey::Shift) &&
+      ::Microsoft::ReactNative::IsModifiedKeyPressed(
+          winrt::CoreWindow::GetForCurrentThread(), winrt::Windows::System::VirtualKey::Control));
+}
+
+void ReactRootView::SetupDevToolsShortcut() noexcept {
+  if (auto xamlRoot = XamlRoot()) {
+    if (std::find(m_subscribedDebuggerRoots.begin(), m_subscribedDebuggerRoots.end(), xamlRoot) ==
+        m_subscribedDebuggerRoots.end()) {
+      if (auto rootContent = xamlRoot.Content()) {
+        m_subscribedDebuggerRoots.push_back(xamlRoot);
+        rootContent.KeyDown(
+            [weakThis = this->get_weak()](const auto & /*sender*/, const xaml::Input::KeyRoutedEventArgs &args) {
+              if (const auto strongThis = weakThis.get()) {
+                if (IsCtrlShiftI(args.Key())) {
+                  ::Microsoft::ReactNative::GetSharedDevManager()->OpenDevTools(
+                      winrt::to_string(strongThis->m_reactNativeHost.InstanceSettings().BundleAppId()));
+                }
+              };
+            });
+      }
+    }
+  }
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactRootView.h

@@ -72,6 +72,7 @@ struct ReactRootView : ReactRootViewT<ReactRootView>, ::Microsoft::ReactNative::
   bool m_isPerspectiveEnabled{true};
   bool m_isInitialized{false};
   bool m_isJSViewAttached{false};
+  bool m_isDebuggerPausedOverlayOpen{false};
   Mso::DispatchQueue m_uiQueue;
   int64_t m_rootTag{-1};
   std::unique_ptr<Mso::React::ReactOptions> m_reactOptions;
@@ -84,9 +85,11 @@ struct ReactRootView : ReactRootViewT<ReactRootView>, ::Microsoft::ReactNative::
   std::shared_ptr<::Microsoft::ReactNative::PreviewKeyboardEventHandlerOnRoot> m_previewKeyboardEventHandlerOnRoot;
   xaml::Controls::ContentControl m_focusSafeHarbor{nullptr};
   xaml::Controls::ContentControl::LosingFocus_revoker m_focusSafeHarborLosingFocusRevoker{};
+  xaml::Controls::Flyout m_debuggerPausedFlyout{nullptr};
   winrt::Grid m_greenBoxGrid{nullptr};
   winrt::TextBlock m_waitingTextBlock{nullptr};
   winrt::SystemNavigationManager::BackRequested_revoker m_backRequestedRevoker{};
+  std::vector<xaml::XamlRoot> m_subscribedDebuggerRoots{};
 
   // Visual tree to support safe harbor
   // this
@@ -102,6 +105,8 @@ struct ReactRootView : ReactRootViewT<ReactRootView>, ::Microsoft::ReactNative::
   void UpdateRootViewInternal() noexcept;
   void ClearLoadingUI() noexcept;
   void EnsureLoadingUI() noexcept;
+  void HideDebuggerPausedOverlay() noexcept;
+  void ShowDebuggerPausedOverlay(const std::string &message, const std::function<void()> &onResume) noexcept;
   void ShowInstanceLoaded() noexcept;
   void ShowInstanceError() noexcept;
   void ShowInstanceWaiting() noexcept;
@@ -112,6 +117,7 @@ struct ReactRootView : ReactRootViewT<ReactRootView>, ::Microsoft::ReactNative::
   bool OnBackRequested() noexcept;
   Mso::React::IReactViewHost *ReactViewHost() noexcept;
   void ReactViewHost(Mso::React::IReactViewHost *viewHost) noexcept;
+  void SetupDevToolsShortcut() noexcept;
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/Utils/LocalBundleReader.cpp

@@ -4,6 +4,7 @@
 #include "pch.h"
 
 #include <Utils/LocalBundleReader.h>
+#include <fmt/format.h>
 #include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.Storage.h>
 #include "Unicode.h"

package/Microsoft.ReactNative/Views/DevMenu.cpp

@@ -6,7 +6,7 @@
 #include "DevMenu.h"
 
 #include <winrt/Windows.ApplicationModel.DataTransfer.h>
-#include "HermesSamplingProfiler.h"
+#include "Hermes/HermesSamplingProfiler.h"
 #include "IReactDispatcher.h"
 #include "Modules/DevSettingsModule.h"
 

package/Microsoft.ReactNative/Views/ShadowNodeBase.cpp

@@ -28,11 +28,19 @@ ViewManagerBase *ShadowNodeBase::GetViewManager() const {
 }
 
 void ShadowNodeBase::updateProperties(winrt::Microsoft::ReactNative::JSValueObject &props) {
-  GetViewManager()->UpdateProperties(this, props);
+  auto viewManager = GetViewManager();
+  if (viewManager) {
+    viewManager->UpdateProperties(this, props);
+  }
 }
 
 void ShadowNodeBase::createView(const winrt::Microsoft::ReactNative::JSValueObject &props) {
-  m_view = GetViewManager()->CreateView(this->m_tag, props);
+  auto viewManager = GetViewManager();
+  if (!viewManager) {
+    return;
+  }
+
+  m_view = viewManager->CreateView(this->m_tag, props);
 
   if (g_HasActualSizeProperty == TriBit::Undefined) {
     if (auto uielement = m_view.try_as<xaml::UIElement>()) {
@@ -49,23 +57,38 @@ bool ShadowNodeBase::NeedsForceLayout() {
 void ShadowNodeBase::dispatchCommand(
     const std::string &commandId,
     winrt::Microsoft::ReactNative::JSValueArray &&commandArgs) {
-  GetViewManager()->DispatchCommand(GetView(), commandId, std::move(commandArgs));
+  auto viewManager = GetViewManager();
+  if (viewManager) {
+    viewManager->DispatchCommand(GetView(), commandId, std::move(commandArgs));
+  }
 }
 
 void ShadowNodeBase::removeAllChildren() {
-  GetViewManager()->RemoveAllChildren(GetView());
+  auto viewManager = GetViewManager();
+  if (viewManager) {
+    viewManager->RemoveAllChildren(GetView());
+  }
 }
 
 void ShadowNodeBase::AddView(ShadowNode &child, int64_t index) {
-  this->GetViewManager()->AddView(GetView(), static_cast<ShadowNodeBase &>(child).GetView(), index);
+  auto viewManager = GetViewManager();
+  if (viewManager) {
+    viewManager->AddView(GetView(), static_cast<ShadowNodeBase &>(child).GetView(), index);
+  }
 }
 
 void ShadowNodeBase::RemoveChildAt(int64_t indexToRemove) {
-  GetViewManager()->RemoveChildAt(GetView(), indexToRemove);
+  auto viewManager = GetViewManager();
+  if (viewManager) {
+    viewManager->RemoveChildAt(GetView(), indexToRemove);
+  }
 }
 
 void ShadowNodeBase::onDropViewInstance() {
-  GetViewManager()->OnDropViewInstance(m_view);
+  auto viewManager = GetViewManager();
+  if (viewManager) {
+    viewManager->OnDropViewInstance(m_view);
+  }
   m_handledKeyboardEventHandler = nullptr;
 }
 
@@ -81,7 +104,12 @@ void ShadowNodeBase::ReplaceView(XamlView view) {
 }
 
 void ShadowNodeBase::ReplaceChild(const XamlView &oldChildView, const XamlView &newChildView) {
-  GetViewManager()->ReplaceChild(m_view, oldChildView, newChildView);
+  // Add safety checks to prevent crashes during cleanup
+  auto viewManager = GetViewManager();
+  if (!viewManager || !m_view || !oldChildView || !newChildView) {
+    return;
+  }
+  viewManager->ReplaceChild(m_view, oldChildView, newChildView);
 }
 
 void ShadowNodeBase::ReparentView(XamlView view) {

package/Microsoft.ReactNative/Views/ShadowNodeRegistry.cpp

@@ -10,8 +10,12 @@
 namespace Microsoft::ReactNative {
 
 void ShadowNodeDeleter::operator()(ShadowNode *node) {
-  if (node->m_viewManager)
-    node->m_viewManager->destroyShadow(node);
+  if (node && node->m_viewManager) {
+    // Clear the view manager pointer to prevent double deletion
+    auto viewManager = node->m_viewManager;
+    node->m_viewManager = nullptr;
+    viewManager->destroyShadow(node);
+  }
 }
 
 void ShadowNodeRegistry::addRootView(std::unique_ptr<ShadowNode, ShadowNodeDeleter> &&root, int64_t rootViewTag) {

package/Microsoft.ReactNative/Views/ViewManager.h

@@ -4,7 +4,6 @@
 #pragma once
 
 #include <JSValue.h>
-#include <cxxreact/CxxModule.h>
 
 namespace Microsoft::ReactNative {
 

package/Microsoft.ReactNative/Views/ViewManagerBase.cpp

@@ -187,7 +187,11 @@ ShadowNode *ViewManagerBase::createShadow() const {
 }
 
 void ViewManagerBase::destroyShadow(ShadowNode *node) const {
-  delete node;
+  if (node) {
+    // Ensure we don't double-delete by clearing the view manager pointer
+    node->m_viewManager = nullptr;
+    delete node;
+  }
 }
 
 void ViewManagerBase::GetExportedCustomBubblingEventTypeConstants(
@@ -293,6 +297,10 @@ void ViewManagerBase::RemoveAllChildren(const XamlView &parent) {}
 
 void ViewManagerBase::ReplaceChild(const XamlView &parent, const XamlView &oldChild, const XamlView &newChild) {
   // ASSERT: Child must either implement or not allow children.
+  // Add null checks to prevent crashes during cleanup
+  if (!parent || !oldChild || !newChild) {
+    return;
+  }
   assert(false);
 }
 

package/Microsoft.ReactNative.Cxx/JSI/decorator.h

@@ -112,6 +112,12 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     return plain_;
   }
 
+  #if JSI_VERSION >= 20
+  ICast* castInterface(const UUID& interfaceUUID) override {
+    return plain().castInterface(interfaceUUID);
+  }
+  #endif
+
   Value evaluateJavaScript(
       const std::shared_ptr<const Buffer>& buffer,
       const std::string& sourceURL) override {
@@ -423,6 +429,19 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     return plain_.callAsConstructor(f, args, count);
   };
 
+  #if JSI_VERSION >= 20
+  void setRuntimeDataImpl(
+      const UUID& uuid,
+      const void* data,
+      void (*deleter)(const void* data)) override {
+    return plain_.setRuntimeDataImpl(uuid, data, deleter);
+  }
+
+  const void* getRuntimeDataImpl(const UUID& uuid) override {
+    return plain_.getRuntimeDataImpl(uuid);
+  }
+  #endif
+
   // Private data for managing scopes.
   Runtime::ScopeState* pushScope() override {
     return plain_.pushScope();
@@ -620,6 +639,13 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
   // the derived class.
   WithRuntimeDecorator(Plain& plain, With& with) : RD(plain), with_(with) {}
 
+  #if JSI_VERSION >= 20
+  ICast* castInterface(const UUID& interfaceUUID) override {
+    Around around{with_};
+    return RD::castInterface(interfaceUUID);
+  }
+  #endif
+
   Value evaluateJavaScript(
       const std::shared_ptr<const Buffer>& buffer,
       const std::string& sourceURL) override {
@@ -1034,6 +1060,21 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
   };
 #endif
 
+  #if JSI_VERSION >= 20
+  void setRuntimeDataImpl(
+      const UUID& uuid,
+      const void* data,
+      void (*deleter)(const void* data)) override {
+    Around around{with_};
+    RD::setRuntimeDataImpl(uuid, data, deleter);
+  }
+
+  const void* getRuntimeDataImpl(const UUID& uuid) override {
+    Around around{with_};
+    return RD::getRuntimeDataImpl(uuid);
+  }
+  #endif
+
  private:
   // Wrap an RAII type around With& to guarantee after always happens.
   struct Around {

package/Microsoft.ReactNative.Cxx/JSI/jsi-inl.h

@@ -86,6 +86,22 @@ inline const Runtime::PointerValue* Runtime::getPointerValue(
   return value.data_.pointer.ptr_;
 }
 
+#if JSI_VERSION >= 20
+inline void Runtime::setRuntimeData(
+    const UUID& uuid,
+    const std::shared_ptr<void>& data) {
+  auto* dataPtr = new std::shared_ptr<void>(data);
+  setRuntimeDataImpl(uuid, dataPtr, [](const void* data) {
+    delete (const std::shared_ptr<void>*)data;
+  });
+}
+
+inline std::shared_ptr<void> Runtime::getRuntimeData(const UUID& uuid) {
+  auto* data = (const std::shared_ptr<void>*)getRuntimeDataImpl(uuid);
+  return data ? *data : nullptr;
+}
+#endif
+
 #if JSI_VERSION >= 17
 Value Object::getPrototype(Runtime& runtime) const {
   return runtime.getPrototypeOf(*this);

package/Microsoft.ReactNative.Cxx/JSI/jsi.cpp

@@ -8,6 +8,8 @@
 #include <cassert>
 #include <cmath>
 #include <cstdlib>
+#include <map>
+#include <mutex>
 #include <stdexcept>
 
 #include <jsi/instrumentation.h>
@@ -18,6 +20,65 @@ namespace jsi {
 
 namespace {
 
+#if JSI_VERSION >= 20
+/// A global map used to store custom runtime data for VMs that do not provide
+/// their own default implementation of setRuntimeData and getRuntimeData.
+struct RuntimeDataGlobal {
+  /// Mutex protecting the Runtime data map
+  std::mutex mutex_{};
+  /// Maps a runtime pointer to a map of its custom data. At destruction of the
+  /// runtime, its entry will be removed from the global map.
+  std::unordered_map<
+      Runtime*,
+      std::unordered_map<
+          UUID,
+          std::pair<const void*, void (*)(const void* data)>,
+          UUID::Hash>>
+      dataMap_;
+};
+
+RuntimeDataGlobal& getRuntimeDataGlobal() {
+  static RuntimeDataGlobal runtimeData{};
+  return runtimeData;
+}
+
+/// A host object that, when destructed, will remove the runtime's custom data
+/// entry from the global map of custom data.
+class RemoveRuntimeDataHostObject : public jsi::HostObject {
+ public:
+  explicit RemoveRuntimeDataHostObject(Runtime* runtime) : runtime_(runtime) {}
+
+  RemoveRuntimeDataHostObject(const RemoveRuntimeDataHostObject&) = default;
+  RemoveRuntimeDataHostObject(RemoveRuntimeDataHostObject&&) = default;
+  RemoveRuntimeDataHostObject& operator=(const RemoveRuntimeDataHostObject&) =
+      default;
+  RemoveRuntimeDataHostObject& operator=(RemoveRuntimeDataHostObject&&) =
+      default;
+
+  ~RemoveRuntimeDataHostObject() override {
+    auto& runtimeDataGlobal = getRuntimeDataGlobal();
+    std::lock_guard<std::mutex> lock(runtimeDataGlobal.mutex_);
+    auto runtimeMapIt = runtimeDataGlobal.dataMap_.find(runtime_);
+    // We install the RemoveRuntimeDataHostObject only when the first custom
+    // data for the runtime is added, and only this object is responsible for
+    // clearing runtime data. Thus, we should always be able to find the data
+    // entry.
+    assert(
+        runtimeMapIt != runtimeDataGlobal.dataMap_.end() &&
+        "Custom runtime data not found for this runtime");
+
+    for (auto [_, entry] : runtimeMapIt->second) {
+      auto* deleter = entry.second;
+      deleter(entry.first);
+    }
+    runtimeDataGlobal.dataMap_.erase(runtime_);
+  }
+
+ private:
+  Runtime* runtime_;
+};
+#endif
+
 // This is used for generating short exception strings.
 std::string kindToString(const Value& v, Runtime* rt = nullptr) {
   if (v.isUndefined()) {
@@ -237,6 +298,12 @@ NativeState::~NativeState() {}
 
 Runtime::~Runtime() {}
 
+#if JSI_VERSION >= 20
+ICast* Runtime::castInterface(const UUID& /*interfaceUUID*/) {
+  return nullptr;
+}
+#endif
+
 Instrumentation& Runtime::instrumentation() {
   class NoInstrumentation : public Instrumentation {
     std::string getRecordedGCStats() override {
@@ -398,6 +465,64 @@ Object Runtime::createObjectWithPrototype(const Value& prototype) {
 }
 #endif
 
+#if JSI_VERSION >= 20
+void Runtime::setRuntimeDataImpl(
+    const UUID& uuid,
+    const void* data,
+    void (*deleter)(const void* data)) {
+  auto& runtimeDataGlobal = getRuntimeDataGlobal();
+  std::lock_guard<std::mutex> lock(runtimeDataGlobal.mutex_);
+  if (auto it = runtimeDataGlobal.dataMap_.find(this);
+      it != runtimeDataGlobal.dataMap_.end()) {
+    auto& map = it->second;
+    if (auto entryIt = map.find(uuid); entryIt != map.end()) {
+      // Free the old data
+      auto oldData = entryIt->second.first;
+      auto oldDataDeleter = entryIt->second.second;
+      oldDataDeleter(oldData);
+    }
+    map[uuid] = {data, deleter};
+    return;
+  }
+  // No custom data entry exist for this runtime in the global map, so create
+  // one.
+  runtimeDataGlobal.dataMap_[this][uuid] = {data, deleter};
+
+  // The first time data is added for this runtime is added to the map, install
+  // a host object on the global object of the runtime. This host object is used
+  // to release the runtime's entry from the global custom data map when the
+  // runtime is destroyed.
+  // Also, try to protect the host object by making it non-configurable,
+  // non-enumerable, and non-writable. These JSI operations are purposely
+  // performed after runtime-specific data map is added and the host object is
+  // created to prevent data leaks if any operations fail.
+  Object ho = Object::createFromHostObject(
+      *this, std::make_shared<RemoveRuntimeDataHostObject>(this));
+  global().setProperty(*this, "_jsiRuntimeDataCleanUp", ho);
+  auto definePropertyFn = global()
+                              .getPropertyAsObject(*this, "Object")
+                              .getPropertyAsFunction(*this, "defineProperty");
+  auto desc = Object(*this);
+  desc.setProperty(*this, "configurable", Value(false));
+  desc.setProperty(*this, "enumerable", Value(false));
+  desc.setProperty(*this, "writable", Value(false));
+  definePropertyFn.call(*this, global(), "_jsiRuntimeDataCleanUp", desc);
+}
+
+const void* Runtime::getRuntimeDataImpl(const UUID& uuid) {
+  auto& runtimeDataGlobal = getRuntimeDataGlobal();
+  std::lock_guard<std::mutex> lock(runtimeDataGlobal.mutex_);
+  if (auto runtimeMapIt = runtimeDataGlobal.dataMap_.find(this);
+      runtimeMapIt != runtimeDataGlobal.dataMap_.end()) {
+    if (auto customDataIt = runtimeMapIt->second.find(uuid);
+        customDataIt != runtimeMapIt->second.end()) {
+      return customDataIt->second.first;
+    }
+  }
+  return nullptr;
+}
+#endif
+
 Pointer& Pointer::operator=(Pointer&& other) JSI_NOEXCEPT_15 {
   if (ptr_) {
     ptr_->invalidate();