react-native-tvos 0.78.0-0rc4 → 0.79.0-0

package/ReactCommon/react/renderer/mounting/stubs/StubView.cpp

@@ -23,6 +23,7 @@ StubView::operator ShadowView() const {
   shadowView.eventEmitter = eventEmitter;
   shadowView.layoutMetrics = layoutMetrics;
   shadowView.state = state;
+  shadowView.traits = traits;
   return shadowView;
 }
 
@@ -35,6 +36,7 @@ void StubView::update(const ShadowView& shadowView) {
   eventEmitter = shadowView.eventEmitter;
   layoutMetrics = shadowView.layoutMetrics;
   state = shadowView.state;
+  traits = shadowView.traits;
 }
 
 bool operator==(const StubView& lhs, const StubView& rhs) {

package/ReactCommon/react/renderer/mounting/stubs/StubView.h

@@ -34,6 +34,7 @@ class StubView final {
   ComponentHandle componentHandle;
   SurfaceId surfaceId;
   Tag tag;
+  ShadowNodeTraits traits{};
   Props::Shared props;
   SharedEventEmitter eventEmitter;
   LayoutMetrics layoutMetrics;

package/ReactCommon/react/renderer/mounting/stubs/StubViewTree.cpp

@@ -7,8 +7,10 @@
 
 #include "StubViewTree.h"
 
+#include <folly/json.h>
 #include <glog/logging.h>
 #include <react/debug/react_native_assert.h>
+#include <sstream>
 
 #ifdef STUB_VIEW_TREE_VERBOSE
 #define STUB_VIEW_LOG(code) code
@@ -18,6 +20,12 @@
 
 namespace facebook::react {
 
+namespace {
+std::string getComponentName(const ShadowView& shadowView) {
+  return std::string{"\""} + shadowView.componentName + "\"";
+}
+} // namespace
+
 StubViewTree::StubViewTree(const ShadowView& shadowView) {
   auto view = std::make_shared<StubView>();
   view->update(shadowView);
@@ -60,6 +68,9 @@ void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
         }
         react_native_assert(!hasTag(tag));
         registry_[tag] = stubView;
+
+        recordMutation(mutation);
+
         break;
       }
 
@@ -92,6 +103,9 @@ void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
         react_native_assert(
             (ShadowView)(*stubView) == mutation.oldChildShadowView);
         registry_.erase(tag);
+
+        recordMutation(mutation);
+
         break;
       }
 
@@ -134,6 +148,9 @@ void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
           auto childStubView = registry_[childTag];
           childStubView->update(mutation.newChildShadowView);
         }
+
+        recordMutation(mutation);
+
         break;
       }
 
@@ -202,6 +219,9 @@ void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
           parentStubView->children.erase(
               parentStubView->children.begin() + mutation.index);
         }
+
+        recordMutation(mutation);
+
         break;
       }
 
@@ -250,6 +270,8 @@ void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
             std::hash<ShadowView>{}((ShadowView)*oldStubView) ==
             std::hash<ShadowView>{}(mutation.newChildShadowView));
 
+        recordMutation(mutation);
+
         break;
       }
     }
@@ -261,6 +283,30 @@ void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
   google::FlushLogFiles(google::GLOG_INFO);
 }
 
+void StubViewTree::dispatchCommand(
+    const ShadowView& shadowView,
+    const std::string& commandName,
+    const folly::dynamic& args) {
+  auto stream = std::ostringstream();
+
+  stream << "Command {type: " << getComponentName(shadowView)
+         << ", nativeID: " << getNativeId(shadowView) << ", name: \""
+         << commandName;
+
+  if (!args.empty()) {
+    stream << ", args: " << folly::toJson(args);
+  }
+
+  stream << "\"}";
+  mountingLogs_.push_back(std::string(stream.str()));
+}
+
+std::vector<std::string> StubViewTree::takeMountingLogs() {
+  auto logs = mountingLogs_;
+  mountingLogs_.clear();
+  return logs;
+}
+
 std::ostream& StubViewTree::dumpTags(std::ostream& stream) const {
   for (const auto& pair : registry_) {
     auto& stubView = *pair.second;
@@ -309,4 +355,85 @@ bool operator!=(const StubViewTree& lhs, const StubViewTree& rhs) {
   return !(lhs == rhs);
 }
 
+void StubViewTree::recordMutation(const ShadowViewMutation& mutation) {
+  switch (mutation.type) {
+    case ShadowViewMutation::Create: {
+      auto stream = std::ostringstream();
+
+      stream << "Create {type: "
+             << getComponentName(mutation.newChildShadowView)
+             << ", nativeID: " << getNativeId(mutation.newChildShadowView)
+             << "}";
+
+      mountingLogs_.push_back(std::string(stream.str()));
+      break;
+    }
+    case ShadowViewMutation::Delete: {
+      auto stream = std::ostringstream();
+
+      stream << "Delete {type: "
+             << getComponentName(mutation.oldChildShadowView)
+             << ", nativeID: " << getNativeId(mutation.oldChildShadowView)
+             << "}";
+
+      mountingLogs_.push_back(std::string(stream.str()));
+      break;
+    }
+    case ShadowViewMutation::Insert: {
+      auto stream = std::ostringstream();
+
+      stream << "Insert {type: "
+             << getComponentName(mutation.newChildShadowView)
+             << ", parentNativeID: " << getNativeId(mutation.parentTag)
+             << ", index: " << mutation.index
+             << ", nativeID: " << getNativeId(mutation.newChildShadowView)
+             << "}";
+
+      mountingLogs_.push_back(std::string(stream.str()));
+      break;
+    }
+    case ShadowViewMutation::Remove: {
+      auto stream = std::ostringstream();
+
+      stream << "Remove {type: "
+             << getComponentName(mutation.oldChildShadowView)
+             << ", parentNativeID: " << getNativeId(mutation.parentTag)
+             << ", index: " << mutation.index
+             << ", nativeID: " << getNativeId(mutation.oldChildShadowView)
+             << "}";
+
+      mountingLogs_.push_back(std::string(stream.str()));
+      break;
+    }
+    case ShadowViewMutation::Update: {
+      auto stream = std::ostringstream();
+
+      stream << "Update {type: "
+             << getComponentName(mutation.newChildShadowView)
+             << ", nativeID: " << getNativeId(mutation.newChildShadowView)
+             << "}";
+
+      mountingLogs_.push_back(std::string(stream.str()));
+      break;
+    }
+  }
+}
+
+std::string StubViewTree::getNativeId(Tag tag) {
+  auto& view = getStubView(tag);
+  return getNativeId(view);
+}
+
+std::string StubViewTree::getNativeId(const ShadowView& shadowView) {
+  if (shadowView.traits.check(ShadowNodeTraits::Trait::RootNodeKind)) {
+    return "(root)";
+  }
+
+  if (shadowView.props->nativeId.empty()) {
+    return "(N/A)";
+  }
+
+  return "\"" + shadowView.props->nativeId + "\"";
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/mounting/stubs/StubViewTree.h

@@ -22,6 +22,11 @@ class StubViewTree {
 
   void mutate(const ShadowViewMutationList& mutations);
 
+  void dispatchCommand(
+      const ShadowView& shadowView,
+      const std::string& commandName,
+      const folly::dynamic& args);
+
   const StubView& getRootStubView() const;
 
   /*
@@ -34,9 +39,15 @@ class StubViewTree {
    */
   size_t size() const;
 
+  /**
+   * Returns the list of mounting operations in the buffer and clears it.
+   */
+  std::vector<std::string> takeMountingLogs();
+
  private:
   Tag rootTag_{};
   std::unordered_map<Tag, StubView::Shared> registry_{};
+  std::vector<std::string> mountingLogs_{};
 
   friend bool operator==(const StubViewTree& lhs, const StubViewTree& rhs);
   friend bool operator!=(const StubViewTree& lhs, const StubViewTree& rhs);
@@ -46,6 +57,10 @@ class StubViewTree {
   bool hasTag(Tag tag) const {
     return registry_.find(tag) != registry_.end();
   }
+
+  std::string getNativeId(Tag tag);
+  std::string getNativeId(const ShadowView& shadowView);
+  void recordMutation(const ShadowViewMutation& mutation);
 };
 
 bool operator==(const StubViewTree& lhs, const StubViewTree& rhs);

package/ReactCommon/react/renderer/mounting/stubs/stubs.cpp

@@ -10,6 +10,8 @@
 #include <react/renderer/core/LayoutableShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
 #include <react/renderer/mounting/Differentiator.h>
+#include "../internal/ShadowViewNodePair.h"
+#include "../internal/sliceChildShadowNodeViewPairs.h"
 
 namespace facebook::react {
 
@@ -60,7 +62,7 @@ static void calculateShadowViewMutationsForNewTree(
         static_cast<int>(newChildPair->mountIndex)));
 
     auto newGrandChildPairs =
-        sliceChildShadowNodeViewPairs(*newChildPair, scope);
+        sliceChildShadowNodeViewPairs(*newChildPair, scope, false, {}, {});
 
     calculateShadowViewMutationsForNewTree(
         mutations, scope, newChildPair->shadowView, newGrandChildPairs);
@@ -78,7 +80,7 @@ StubViewTree buildStubViewTreeWithoutUsingDifferentiator(
       mutations,
       scope,
       ShadowView(rootShadowNode),
-      sliceChildShadowNodeViewPairs(rootShadowNodePair, scope));
+      sliceChildShadowNodeViewPairs(rootShadowNodePair, scope, false, {}, {}));
 
   auto emptyRootShadowNode = rootShadowNode.clone(ShadowNodeFragment{
       ShadowNodeFragment::propsPlaceholder(),

package/ReactCommon/react/renderer/mounting/tests/ShadowTreeLifeCycleTest.cpp

@@ -387,15 +387,17 @@ TEST(
 }
 
 // failing test case found 4-25-2021
-TEST(
-    ShadowTreeLifecycleTest,
-    unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening_1167342011) {
-  testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
-      /* seed */ 1167342011,
-      /* size */ 32,
-      /* repeats */ 512,
-      /* stages */ 32);
-}
+// TODO: T213669056
+// TEST(
+//     ShadowTreeLifecycleTest,
+//     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening_1167342011)
+//     {
+//   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
+//       /* seed */ 1167342011,
+//       /* size */ 32,
+//       /* repeats */ 512,
+//       /* stages */ 32);
+// }
 
 // You may uncomment this - locally only! - to generate failing seeds.
 // TEST(

package/ReactCommon/react/renderer/observers/events/CMakeLists.txt

@@ -14,15 +14,15 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB react_render_observers_events_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_observers_events OBJECT ${react_render_observers_events_SRC})
+file(GLOB react_renderer_observers_events_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_renderer_observers_events OBJECT ${react_renderer_observers_events_SRC})
 
-target_include_directories(react_render_observers_events PUBLIC ${REACT_COMMON_DIR})
-target_link_libraries(react_render_observers_events
+target_include_directories(react_renderer_observers_events PUBLIC ${REACT_COMMON_DIR})
+target_link_libraries(react_renderer_observers_events
         react_performance_timeline
         react_timing
-        react_render_core
-        react_render_runtimescheduler
+        react_renderer_core
+        react_renderer_runtimescheduler
         react_featureflags
-        react_render_uimanager
+        react_renderer_uimanager
         react_utils)

package/ReactCommon/react/renderer/runtimescheduler/CMakeLists.txt

@@ -14,19 +14,20 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB react_render_runtimescheduler_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_runtimescheduler STATIC ${react_render_runtimescheduler_SRC})
+file(GLOB react_renderer_runtimescheduler_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_renderer_runtimescheduler STATIC ${react_renderer_runtimescheduler_SRC})
 
-target_include_directories(react_render_runtimescheduler PUBLIC ${REACT_COMMON_DIR})
+target_include_directories(react_renderer_runtimescheduler PUBLIC ${REACT_COMMON_DIR})
 
-target_link_libraries(react_render_runtimescheduler
+target_link_libraries(react_renderer_runtimescheduler
         callinvoker
         jsi
         react_debug
         react_performance_timeline
-        react_render_consistency
-        react_render_debug
+        react_renderer_consistency
+        react_renderer_debug
         react_timing
         react_utils
         react_featureflags
-        runtimeexecutor)
+        runtimeexecutor
+        jsinspector_tracing)

package/ReactCommon/react/renderer/runtimescheduler/React-runtimescheduler.podspec

@@ -64,11 +64,7 @@ Pod::Spec.new do |s|
   s.dependency "React-performancetimeline"
   s.dependency "React-rendererconsistency"
   add_dependency(s, "React-debug")
+  add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
 
-  if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
-    s.dependency "hermes-engine"
-  else
-    s.dependency "React-jsc"
-  end
-
+  depend_on_js_engine(s)
 end

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.cpp

@@ -24,8 +24,7 @@ std::unique_ptr<RuntimeSchedulerBase> getRuntimeSchedulerImplementation(
     RuntimeExecutor runtimeExecutor,
     std::function<RuntimeSchedulerTimePoint()> now,
     RuntimeSchedulerTaskErrorHandler onTaskError) {
-  if (ReactNativeFeatureFlags::enableBridgelessArchitecture() &&
-      !ReactNativeFeatureFlags::disableEventLoopOnBridgeless()) {
+  if (ReactNativeFeatureFlags::enableBridgelessArchitecture()) {
     return std::make_unique<RuntimeScheduler_Modern>(
         std::move(runtimeExecutor), std::move(now), std::move(onTaskError));
   } else {

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.cpp

@@ -9,6 +9,7 @@
 #include "SchedulerPriorityUtils.h"
 
 #include <cxxreact/TraceSection.h>
+#include <jsinspector-modern/tracing/EventLoopTaskReporter.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/consistency/ScopedShadowTreeRevisionLock.h>
 #include <react/timing/primitives.h>
@@ -308,6 +309,8 @@ void RuntimeScheduler_Modern::runEventLoopTick(
     Task& task,
     RuntimeSchedulerTimePoint taskStartTime) {
   TraceSection s("RuntimeScheduler::runEventLoopTick");
+  [[maybe_unused]] jsinspector_modern::tracing::EventLoopTaskReporter
+      performanceReporter;
 
   ScopedShadowTreeRevisionLock revisionLock(
       shadowTreeRevisionConsistencyManager_);

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.h

@@ -42,7 +42,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * Alias for scheduleTask with immediate priority.
    *
    * To be removed when we finish testing this implementation.
-   * All callers should use scheduleTask with the right priority afte that.
+   * All callers should use scheduleTask with the right priority after that.
    */
   void scheduleWork(RawCallback&& callback) noexcept override;
 

package/ReactCommon/react/renderer/scheduler/CMakeLists.txt

@@ -14,26 +14,26 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB react_render_scheduler_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_scheduler STATIC ${react_render_scheduler_SRC})
+file(GLOB react_renderer_scheduler_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_renderer_scheduler STATIC ${react_renderer_scheduler_SRC})
 
-target_include_directories(react_render_scheduler PUBLIC ${REACT_COMMON_DIR})
+target_include_directories(react_renderer_scheduler PUBLIC ${REACT_COMMON_DIR})
 
-target_link_libraries(react_render_scheduler
+target_link_libraries(react_renderer_scheduler
         folly_runtime
         glog
         jsi
         react_debug
         react_featureflags
         react_performance_timeline
-        react_render_componentregistry
-        react_render_core
-        react_render_debug
-        react_render_graphics
-        react_render_mounting
-        react_render_observers_events
-        react_render_runtimescheduler
-        react_render_uimanager
+        react_renderer_componentregistry
+        react_renderer_core
+        react_renderer_debug
+        react_renderer_graphics
+        react_renderer_mounting
+        react_renderer_observers_events
+        react_renderer_runtimescheduler
+        react_renderer_uimanager
         react_utils
         rrc_root
         rrc_view

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -285,19 +285,14 @@ void Scheduler::uiManagerDidDispatchCommand(
 
   if (delegate_ != nullptr) {
     auto shadowView = ShadowView(*shadowNode);
-    if (ReactNativeFeatureFlags::enableFixForViewCommandRace()) {
-      runtimeScheduler_->scheduleRenderingUpdate(
-          shadowNode->getSurfaceId(),
-          [delegate = delegate_,
-           shadowView = std::move(shadowView),
-           commandName,
-           args]() {
-            delegate->schedulerDidDispatchCommand(
-                shadowView, commandName, args);
-          });
-    } else {
-      delegate_->schedulerDidDispatchCommand(shadowView, commandName, args);
-    }
+    runtimeScheduler_->scheduleRenderingUpdate(
+        shadowNode->getSurfaceId(),
+        [delegate = delegate_,
+         shadowView = std::move(shadowView),
+         commandName,
+         args]() {
+          delegate->schedulerDidDispatchCommand(shadowView, commandName, args);
+        });
   }
 }
 

package/ReactCommon/react/renderer/scheduler/SurfaceHandler.cpp

@@ -210,7 +210,7 @@ SurfaceHandler::getMountingCoordinator() const noexcept {
 
 Size SurfaceHandler::measure(
     const LayoutConstraints& layoutConstraints,
-    const LayoutContext& layoutContext) const noexcept {
+    const LayoutContext& layoutContext) const {
   std::shared_lock lock(linkMutex_);
 
   if (link_.status != Status::Running) {
@@ -234,7 +234,7 @@ Size SurfaceHandler::measure(
 
 void SurfaceHandler::constraintLayout(
     const LayoutConstraints& layoutConstraints,
-    const LayoutContext& layoutContext) const noexcept {
+    const LayoutContext& layoutContext) const {
   TraceSection s("SurfaceHandler::constraintLayout");
   {
     std::unique_lock lock(parametersMutex_);
@@ -281,7 +281,7 @@ LayoutContext SurfaceHandler::getLayoutContext() const noexcept {
 
 #pragma mark - Private
 
-void SurfaceHandler::applyDisplayMode(DisplayMode displayMode) const noexcept {
+void SurfaceHandler::applyDisplayMode(DisplayMode displayMode) const {
   TraceSection s("SurfaceHandler::applyDisplayMode");
   react_native_assert(
       link_.status == Status::Running && "Surface must be running.");

package/ReactCommon/react/renderer/scheduler/SurfaceHandler.h

@@ -131,14 +131,14 @@ class SurfaceHandler {
    */
   Size measure(
       const LayoutConstraints& layoutConstraints,
-      const LayoutContext& layoutContext) const noexcept;
+      const LayoutContext& layoutContext) const;
 
   /*
    * Sets layout constraints and layout context for the surface.
    */
   void constraintLayout(
       const LayoutConstraints& layoutConstraints,
-      const LayoutContext& layoutContext) const noexcept;
+      const LayoutContext& layoutContext) const;
 
   /*
    * Returns layout constraints and layout context associated with the surface.
@@ -154,7 +154,7 @@ class SurfaceHandler {
    */
   void setUIManager(const UIManager* uiManager) const noexcept;
 
-  void applyDisplayMode(DisplayMode displayMode) const noexcept;
+  void applyDisplayMode(DisplayMode displayMode) const;
 
 #pragma mark - Link & Parameters
 

package/ReactCommon/react/renderer/telemetry/CMakeLists.txt

@@ -14,18 +14,18 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB react_render_telemetry_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_telemetry OBJECT ${react_render_telemetry_SRC})
+file(GLOB react_renderer_telemetry_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_renderer_telemetry OBJECT ${react_renderer_telemetry_SRC})
 
-target_include_directories(react_render_telemetry PUBLIC ${REACT_COMMON_DIR})
+target_include_directories(react_renderer_telemetry PUBLIC ${REACT_COMMON_DIR})
 
-target_link_libraries(react_render_telemetry
+target_link_libraries(react_renderer_telemetry
         folly_runtime
         glog
         glog_init
         react_debug
-        react_render_core
-        react_render_debug
+        react_renderer_core
+        react_renderer_debug
         react_utils
         rrc_root
         rrc_view

package/ReactCommon/react/renderer/textlayoutmanager/CMakeLists.txt

@@ -14,35 +14,35 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB react_render_textlayourmanager_SRC CONFIGURE_DEPENDS
+file(GLOB react_renderer_textlayourmanager_SRC CONFIGURE_DEPENDS
         *.cpp
         platform/android/react/renderer/textlayoutmanager/*.cpp)
 
-add_library(react_render_textlayoutmanager
+add_library(react_renderer_textlayoutmanager
         OBJECT
-        ${react_render_textlayourmanager_SRC})
+        ${react_renderer_textlayourmanager_SRC})
 
-target_include_directories(react_render_textlayoutmanager
+target_include_directories(react_renderer_textlayoutmanager
         PUBLIC
           .
           ${REACT_COMMON_DIR}
           ${CMAKE_CURRENT_SOURCE_DIR}/platform/android/
 )
 
-target_link_libraries(react_render_textlayoutmanager
+target_link_libraries(react_renderer_textlayoutmanager
         glog
         fbjni
         folly_runtime
         mapbufferjni
         react_debug
-        react_render_attributedstring
-        react_render_componentregistry
-        react_render_core
-        react_render_debug
-        react_render_graphics
-        react_render_mapbuffer
-        react_render_mounting
-        react_render_telemetry
+        react_renderer_attributedstring
+        react_renderer_componentregistry
+        react_renderer_core
+        react_renderer_debug
+        react_renderer_graphics
+        react_renderer_mapbuffer
+        react_renderer_mounting
+        react_renderer_telemetry
         react_utils
         reactnativejni
         yoga

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTAttributedTextUtils.h

@@ -52,8 +52,29 @@ BOOL RCTIsAttributedStringEffectivelySame(
     NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes,
     const facebook::react::TextAttributes &baseTextAttributes);
 
-@interface RCTWeakEventEmitterWrapper : NSObject
-@property (nonatomic, assign) facebook::react::SharedEventEmitter eventEmitter;
-@end
+static inline NSData *RCTWrapEventEmitter(const facebook::react::SharedEventEmitter &eventEmitter)
+{
+  auto eventEmitterPtr = new std::weak_ptr<const facebook::react::EventEmitter>(eventEmitter);
+  return [[NSData alloc] initWithBytesNoCopy:eventEmitterPtr
+                                      length:sizeof(eventEmitterPtr)
+                                 deallocator:^(void *ptrToDelete, NSUInteger) {
+                                   delete (std::weak_ptr<facebook::react::EventEmitter> *)ptrToDelete;
+                                 }];
+}
+
+static inline facebook::react::SharedEventEmitter RCTUnwrapEventEmitter(NSData *data)
+{
+  if (data.length == 0) {
+    return nullptr;
+  }
+
+  auto weakPtr = dynamic_cast<std::weak_ptr<const facebook::react::EventEmitter> *>(
+      (std::weak_ptr<const facebook::react::EventEmitter> *)data.bytes);
+  if (weakPtr) {
+    return weakPtr->lock();
+  }
+
+  return nullptr;
+}
 
 NS_ASSUME_NONNULL_END