Add getDefinedEventHandlers API

Summary:
Add Fantom.getDefinedEventHandlers(element) which returns the names of
event handlers registered on a component's shadow node.

Changelog: [Internal]

Differential Revision: D94936370

Author: sammy-SC

packages/react-native/Libraries/Components/View/__tests__/FantomEventHandlers-itest.js

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import '@react-native/fantom/src/setUpDefaultReactNativeEnvironment';
+
+import * as Fantom from '@react-native/fantom';
+import * as React from 'react';
+import {createRef} from 'react';
+import {View} from 'react-native';
+
+describe('Fantom.getDefinedEventHandlers', () => {
+  it('returns event handler names registered on a view', () => {
+    const root = Fantom.createRoot();
+    const ref = createRef<React.ElementRef<typeof View>>();
+
+    Fantom.runTask(() => {
+      root.render(
+        <View ref={ref} onLayout={() => {}} onTouchStart={() => {}} />,
+      );
+    });
+
+    const handlers = Fantom.getDefinedEventHandlers(ref);
+    expect(handlers).toContain('onLayout');
+    expect(handlers).toContain('onTouchStart');
+  });
+
+  it('returns an empty array when no event handlers are registered', () => {
+    const root = Fantom.createRoot();
+    const ref = createRef<React.ElementRef<typeof View>>();
+
+    Fantom.runTask(() => {
+      root.render(<View ref={ref} />);
+    });
+
+    expect(Fantom.getDefinedEventHandlers(ref)).toEqual([]);
+  });
+
+  it('returns multiple event handler names when multiple are registered', () => {
+    const root = Fantom.createRoot();
+    const ref = createRef<React.ElementRef<typeof View>>();
+
+    Fantom.runTask(() => {
+      root.render(
+        <View
+          ref={ref}
+          onLayout={() => {}}
+          onTouchStart={() => {}}
+          onTouchEnd={() => {}}
+          onTouchCancel={() => {}}
+          onClick={() => {}}
+        />,
+      );
+    });
+
+    const handlers = Fantom.getDefinedEventHandlers(ref);
+    expect(handlers).toContain('onLayout');
+    expect(handlers).toContain('onTouchStart');
+    expect(handlers).toContain('onTouchEnd');
+    expect(handlers).toContain('onTouchCancel');
+    expect(handlers).toContain('onClick');
+  });
+});

packages/react-native/src/private/testing/fantom/specs/NativeFantom.js

@@ -99,6 +99,9 @@ interface Spec extends TurboModule {
     width: number,
   ) => void;
   takeMountingManagerLogs: (surfaceId: RootTag) => Array<string>;
+  getDefinedEventHandlers: (
+    shadowNode: unknown /* ShadowNode */,
+  ) => Array<string>;
   getDirectManipulationProps: (
     shadowNode: unknown /* ShadowNode */,
   ) => Readonly<{

private/react-native-fantom/src/index.js

@@ -237,6 +237,20 @@ export function unstable_getFabricUpdateProps(nodeOrRef: NodeOrRef): Readonly<{
   return NativeFantom.getFabricUpdateProps(shadowNode);
 }
 
+/**
+ * Returns the names of event handlers registered on a component's shadow node.
+ *
+ * @param nodeOrRef - The node or ref for which to retrieve event handlers.
+ * @returns Array of event handler prop names (e.g. `['onLayout', 'onTouchStart']`)
+ */
+export function getDefinedEventHandlers(
+  nodeOrRef: NodeOrRef,
+): ReadonlyArray<string> {
+  const node = getNode(nodeOrRef);
+  const shadowNode = getNativeNodeReference(node);
+  return NativeFantom.getDefinedEventHandlers(shadowNode);
+}
+
 /**
  * Simulates running a task on the UI thread and forces side effect to drain
  * the event queue, scheduling events to be dispatched to JavaScript.

private/react-native-fantom/tester/src/NativeFantom.cpp

@@ -13,6 +13,8 @@
 #include <react/debug/flags.h>
 #include <react/renderer/components/modal/ModalHostViewShadowNode.h>
 #include <react/renderer/components/scrollview/ScrollViewShadowNode.h>
+#include <react/renderer/components/view/BaseViewProps.h>
+#include <react/renderer/components/view/primitives.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <fstream>
 #include <iostream>
@@ -86,7 +88,8 @@ std::string NativeFantom::getRenderedOutput(
     SurfaceId surfaceId,
     NativeFantomGetRenderedOutputRenderFormatOptions options) {
   RenderFormatOptions formatOptions{
-      options.includeRoot, options.includeLayoutMetrics};
+      .includeRoot = options.includeRoot,
+      .includeLayoutMetrics = options.includeLayoutMetrics};
 
   auto viewTree = appDelegate_.mountingManager_->getViewTree(surfaceId);
   return appDelegate_.mountingManager_->renderer()->render(
@@ -107,6 +110,133 @@ jsi::Object NativeFantom::getDirectManipulationProps(
   return facebook::jsi::valueFromDynamic(runtime, props).asObject(runtime);
 }
 
+std::vector<std::string> NativeFantom::getDefinedEventHandlers(
+    jsi::Runtime& /*runtime*/,
+    const std::shared_ptr<const ShadowNode>& shadowNode) {
+  std::vector<std::string> result;
+  result.reserve(36);
+
+  const auto* viewProps =
+      dynamic_cast<const BaseViewProps*>(shadowNode->getProps().get());
+  if (viewProps == nullptr) {
+    return result;
+  }
+
+  if (viewProps->onLayout) {
+    result.emplace_back("onLayout");
+  }
+
+  const auto& events = viewProps->events;
+
+  if (events[ViewEvents::Offset::PointerEnter]) {
+    result.emplace_back("onPointerEnter");
+  }
+  if (events[ViewEvents::Offset::PointerMove]) {
+    result.emplace_back("onPointerMove");
+  }
+  if (events[ViewEvents::Offset::PointerLeave]) {
+    result.emplace_back("onPointerLeave");
+  }
+  if (events[ViewEvents::Offset::MoveShouldSetResponder]) {
+    result.emplace_back("onMoveShouldSetResponder");
+  }
+  if (events[ViewEvents::Offset::MoveShouldSetResponderCapture]) {
+    result.emplace_back("onMoveShouldSetResponderCapture");
+  }
+  if (events[ViewEvents::Offset::StartShouldSetResponder]) {
+    result.emplace_back("onStartShouldSetResponder");
+  }
+  if (events[ViewEvents::Offset::StartShouldSetResponderCapture]) {
+    result.emplace_back("onStartShouldSetResponderCapture");
+  }
+  if (events[ViewEvents::Offset::ResponderGrant]) {
+    result.emplace_back("onResponderGrant");
+  }
+  if (events[ViewEvents::Offset::ResponderReject]) {
+    result.emplace_back("onResponderReject");
+  }
+  if (events[ViewEvents::Offset::ResponderStart]) {
+    result.emplace_back("onResponderStart");
+  }
+  if (events[ViewEvents::Offset::ResponderEnd]) {
+    result.emplace_back("onResponderEnd");
+  }
+  if (events[ViewEvents::Offset::ResponderRelease]) {
+    result.emplace_back("onResponderRelease");
+  }
+  if (events[ViewEvents::Offset::ResponderMove]) {
+    result.emplace_back("onResponderMove");
+  }
+  if (events[ViewEvents::Offset::ResponderTerminate]) {
+    result.emplace_back("onResponderTerminate");
+  }
+  if (events[ViewEvents::Offset::ResponderTerminationRequest]) {
+    result.emplace_back("onResponderTerminationRequest");
+  }
+  if (events[ViewEvents::Offset::ShouldBlockNativeResponder]) {
+    result.emplace_back("onShouldBlockNativeResponder");
+  }
+  if (events[ViewEvents::Offset::TouchStart]) {
+    result.emplace_back("onTouchStart");
+  }
+  if (events[ViewEvents::Offset::TouchMove]) {
+    result.emplace_back("onTouchMove");
+  }
+  if (events[ViewEvents::Offset::TouchEnd]) {
+    result.emplace_back("onTouchEnd");
+  }
+  if (events[ViewEvents::Offset::TouchCancel]) {
+    result.emplace_back("onTouchCancel");
+  }
+  if (events[ViewEvents::Offset::PointerEnterCapture]) {
+    result.emplace_back("onPointerEnterCapture");
+  }
+  if (events[ViewEvents::Offset::PointerLeaveCapture]) {
+    result.emplace_back("onPointerLeaveCapture");
+  }
+  if (events[ViewEvents::Offset::PointerMoveCapture]) {
+    result.emplace_back("onPointerMoveCapture");
+  }
+  if (events[ViewEvents::Offset::PointerOver]) {
+    result.emplace_back("onPointerOver");
+  }
+  if (events[ViewEvents::Offset::PointerOut]) {
+    result.emplace_back("onPointerOut");
+  }
+  if (events[ViewEvents::Offset::PointerOverCapture]) {
+    result.emplace_back("onPointerOverCapture");
+  }
+  if (events[ViewEvents::Offset::PointerOutCapture]) {
+    result.emplace_back("onPointerOutCapture");
+  }
+  if (events[ViewEvents::Offset::Click]) {
+    result.emplace_back("onClick");
+  }
+  if (events[ViewEvents::Offset::ClickCapture]) {
+    result.emplace_back("onClickCapture");
+  }
+  if (events[ViewEvents::Offset::GotPointerCapture]) {
+    result.emplace_back("onGotPointerCapture");
+  }
+  if (events[ViewEvents::Offset::LostPointerCapture]) {
+    result.emplace_back("onLostPointerCapture");
+  }
+  if (events[ViewEvents::Offset::PointerDown]) {
+    result.emplace_back("onPointerDown");
+  }
+  if (events[ViewEvents::Offset::PointerDownCapture]) {
+    result.emplace_back("onPointerDownCapture");
+  }
+  if (events[ViewEvents::Offset::PointerUp]) {
+    result.emplace_back("onPointerUp");
+  }
+  if (events[ViewEvents::Offset::PointerUpCapture]) {
+    result.emplace_back("onPointerUpCapture");
+  }
+
+  return result;
+}
+
 jsi::Object NativeFantom::getFabricUpdateProps(
     jsi::Runtime& runtime,
     const std::shared_ptr<const ShadowNode>& shadowNode) {
@@ -124,10 +254,10 @@ void NativeFantom::enqueueNativeEvent(
     std::optional<bool> isUnique) {
   if (isUnique.value_or(false)) {
     shadowNode->getEventEmitter()->dispatchUniqueEvent(
-        std::move(type), payload.value_or(folly::dynamic::object()));
+        type, payload.value_or(folly::dynamic::object()));
   } else {
     shadowNode->getEventEmitter()->dispatchEvent(
-        std::move(type),
+        type,
         payload.value_or(folly::dynamic::object()),
         category.value_or(RawEvent::Category::Unspecified));
   }

private/react-native-fantom/tester/src/NativeFantom.h

@@ -114,6 +114,10 @@ class NativeFantom : public NativeFantomCxxSpec<NativeFantom> {
 
   jsi::Object getDirectManipulationProps(jsi::Runtime &runtime, const std::shared_ptr<const ShadowNode> &shadowNode);
 
+  std::vector<std::string> getDefinedEventHandlers(
+      jsi::Runtime &runtime,
+      const std::shared_ptr<const ShadowNode> &shadowNode);
+
   jsi::Object getFabricUpdateProps(jsi::Runtime &runtime, const std::shared_ptr<const ShadowNode> &shadowNode);
 
   void enqueueModalSizeUpdate(