@depup/react-native 0.85.0-depup.1 → 0.86.2-depup.0

package/Libraries/ReactNative/DeprecatedPerformanceLoggerStub.js

@@ -0,0 +1,83 @@
+/**
+ * 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 type {IPerformanceLogger} from './IPerformanceLogger.flow';
+
+let didWarn: boolean = false;
+function warnDeprecated(): void {
+  if (didWarn) {
+    return;
+  }
+  didWarn = true;
+  console.warn(
+    'The default `IPerformanceLogger` provided by `react-native` (the ' +
+      "`'GlobalPerformanceLogger'` callable native module and the " +
+      '`scopedPerformanceLogger` argument passed to the hook registered with ' +
+      '`AppRegistry.setComponentProviderInstrumentationHook`) is deprecated and ' +
+      'will be removed in a future release. The instance supplied today is a ' +
+      'no-op stub. Embedders that need a per-app performance logger should ' +
+      'attach their own implementation.',
+  );
+}
+
+/**
+ * @deprecated The `react-native` package no longer ships a real
+ * `IPerformanceLogger`. This stub is exposed to keep existing extension points
+ * (the `'GlobalPerformanceLogger'` callable native module and the second
+ * argument of `AppRegistry.setComponentProviderInstrumentationHook`'s hook)
+ * source-compatible for embedders. Every method is a no-op that emits a
+ * one-time deprecation warning on first use.
+ */
+const DeprecatedPerformanceLoggerStub: IPerformanceLogger = {
+  addTimespan: () => warnDeprecated(),
+  append: () => warnDeprecated(),
+  clear: () => warnDeprecated(),
+  clearCompleted: () => warnDeprecated(),
+  close: () => warnDeprecated(),
+  currentTimestamp: () => {
+    warnDeprecated();
+    return 0;
+  },
+  getExtras: () => {
+    warnDeprecated();
+    return {};
+  },
+  getPoints: () => {
+    warnDeprecated();
+    return {};
+  },
+  getPointExtras: () => {
+    warnDeprecated();
+    return {};
+  },
+  getTimespans: () => {
+    warnDeprecated();
+    return {};
+  },
+  hasTimespan: () => {
+    warnDeprecated();
+    return false;
+  },
+  isClosed: () => {
+    warnDeprecated();
+    return false;
+  },
+  logEverything: () => warnDeprecated(),
+  markPoint: () => warnDeprecated(),
+  removeExtra: () => {
+    warnDeprecated();
+    return undefined;
+  },
+  setExtra: () => warnDeprecated(),
+  startTimespan: () => warnDeprecated(),
+  stopTimespan: () => warnDeprecated(),
+};
+
+export default DeprecatedPerformanceLoggerStub;

package/Libraries/ReactNative/FabricUIManager.js

@@ -92,6 +92,11 @@ export interface Spec {
     /* width: */ number,
     /* height: */ number,
   ];
+  +setIsJSResponder: (
+    node: Node | NativeElementReference,
+    isJSResponder: boolean,
+    blockNativeResponder: boolean,
+  ) => void;
   +unstable_DefaultEventPriority: number;
   +unstable_DiscreteEventPriority: number;
   +unstable_ContinuousEventPriority: number;
@@ -124,6 +129,7 @@ const CACHED_PROPERTIES = [
   'dispatchCommand',
   'compareDocumentPosition',
   'getBoundingClientRect',
+  'setIsJSResponder',
   'unstable_DefaultEventPriority',
   'unstable_DiscreteEventPriority',
   'unstable_ContinuousEventPriority',

package/Libraries/{Utilities → ReactNative}/IPerformanceLogger.d.ts

@@ -7,6 +7,8 @@
  * @format
  */
 
+export type ExtraValue = number | string | boolean;
+export type Extras = {[key: string]: ExtraValue};
 export type Timespan = {
   startTime: number;
   endTime?: number | undefined;
@@ -15,11 +17,12 @@ export type Timespan = {
   endExtras?: Extras | undefined;
 };
 
-// Extra values should be serializable primitives
-export type ExtraValue = number | string | boolean;
-
-export type Extras = {[key: string]: ExtraValue};
-
+/**
+ * @deprecated The scoped performance logger argument passed to the
+ * `componentProviderInstrumentationHook` is no longer used by `react-native`
+ * itself and will be removed in a future release. The instance supplied today
+ * is a no-op stub.
+ */
 export interface IPerformanceLogger {
   addTimespan(
     key: string,

package/Libraries/{Utilities/IPerformanceLogger.js → ReactNative/IPerformanceLogger.flow.js}

@@ -8,6 +8,8 @@
  * @format
  */
 
+export type ExtraValue = number | string | boolean;
+export type Extras = {[key: string]: ExtraValue};
 export type Timespan = {
   startTime: number,
   endTime?: number,
@@ -16,11 +18,12 @@ export type Timespan = {
   endExtras?: Extras,
 };
 
-// Extra values should be serializable primitives
-export type ExtraValue = number | string | boolean;
-
-export type Extras = {[key: string]: ExtraValue};
-
+/**
+ * @deprecated The scoped performance logger argument passed to the
+ * `componentProviderInstrumentationHook` is no longer used by `react-native`
+ * itself and will be removed in a future release. The instance supplied today
+ * is a no-op stub.
+ */
 export interface IPerformanceLogger {
   addTimespan(
     key: string,
@@ -34,10 +37,10 @@ export interface IPerformanceLogger {
   clearCompleted(): void;
   close(): void;
   currentTimestamp(): number;
-  getExtras(): Readonly<{[key: string]: ?ExtraValue, ...}>;
-  getPoints(): Readonly<{[key: string]: ?number, ...}>;
-  getPointExtras(): Readonly<{[key: string]: ?Extras, ...}>;
-  getTimespans(): Readonly<{[key: string]: ?Timespan, ...}>;
+  getExtras(): Readonly<{[key: string]: ?ExtraValue}>;
+  getPoints(): Readonly<{[key: string]: ?number}>;
+  getPointExtras(): Readonly<{[key: string]: ?Extras}>;
+  getTimespans(): Readonly<{[key: string]: ?Timespan}>;
   hasTimespan(key: string): boolean;
   isClosed(): boolean;
   logEverything(): void;

package/Libraries/ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload.js

@@ -258,11 +258,11 @@ function diffProperties(
       if (!attributeConfigHasProcess) {
         // functions are converted to booleans as markers that the associated
         // events should be sent from native.
-        nextProp = (true: any);
+        nextProp = true as any;
         // If nextProp is not a function, then don't bother changing prevProp
         // since nextProp will win and go into the updatePayload regardless.
         if (typeof prevProp === 'function') {
-          prevProp = (true: any);
+          prevProp = true as any;
         }
       }
     }
@@ -270,9 +270,9 @@ function diffProperties(
     // An explicit value of undefined is treated as a null because it overrides
     // any other preceding value.
     if (typeof nextProp === 'undefined') {
-      nextProp = (null: any);
+      nextProp = null as any;
       if (typeof prevProp === 'undefined') {
-        prevProp = (null: any);
+        prevProp = null as any;
       }
     }
 
@@ -313,7 +313,7 @@ function diffProperties(
       // case: !Object is the default case
       if (defaultDiffer(prevProp, nextProp)) {
         // a normal leaf has changed
-        (updatePayload || (updatePayload = ({}: {[string]: $FlowFixMe})))[
+        (updatePayload || (updatePayload = {} as {[string]: $FlowFixMe}))[
           propKey
         ] = nextProp;
       }
@@ -333,7 +333,7 @@ function diffProperties(
             ? // $FlowFixMe[incompatible-use] found when upgrading Flow
               attributeConfig.process(nextProp)
             : nextProp;
-        (updatePayload || (updatePayload = ({}: {[string]: $FlowFixMe})))[
+        (updatePayload || (updatePayload = {} as {[string]: $FlowFixMe}))[
           propKey
         ] = nextValue;
       }
@@ -347,13 +347,13 @@ function diffProperties(
         updatePayload,
         prevProp,
         nextProp,
-        ((attributeConfig: any): AttributeConfiguration),
+        attributeConfig as any as AttributeConfiguration,
       );
       if (removedKeyCount > 0 && updatePayload) {
         restoreDeletedValuesInNestedArray(
           updatePayload,
           nextProp,
-          ((attributeConfig: any): AttributeConfiguration),
+          attributeConfig as any as AttributeConfiguration,
         );
         removedKeys = null;
       }
@@ -389,11 +389,11 @@ function diffProperties(
     ) {
       // case: CustomAttributeConfiguration | !Object
       // Flag the leaf property for removal by sending a sentinel.
-      (updatePayload || (updatePayload = ({}: {[string]: $FlowFixMe})))[
+      (updatePayload || (updatePayload = {} as {[string]: $FlowFixMe}))[
         propKey
       ] = null;
       if (!removedKeys) {
-        removedKeys = ({}: {[string]: boolean});
+        removedKeys = {} as {[string]: boolean};
       }
       if (!removedKeys[propKey]) {
         removedKeys[propKey] = true;
@@ -406,7 +406,7 @@ function diffProperties(
       updatePayload = clearNestedProperty(
         updatePayload,
         prevProp,
-        ((attributeConfig: any): AttributeConfiguration),
+        attributeConfig as any as AttributeConfiguration,
       );
     }
   }
@@ -429,9 +429,9 @@ function addNestedProperty(
   for (const propKey in props) {
     const prop = props[propKey];
 
-    const attributeConfig = ((validAttributes[
+    const attributeConfig = validAttributes[
       propKey
-    ]: any): AttributeConfiguration);
+    ] as any as AttributeConfiguration;
 
     if (attributeConfig == null) {
       continue;
@@ -466,7 +466,7 @@ function addNestedProperty(
 
     if (newValue !== undefined) {
       if (!payload) {
-        payload = ({}: {[string]: $FlowFixMe});
+        payload = {} as {[string]: $FlowFixMe};
       }
       payload[propKey] = newValue;
       continue;

package/Libraries/ReactNative/RendererImplementation.js

@@ -8,9 +8,6 @@
  * @format
  */
 
-import type {HostInstance} from '../../src/private/types/HostInstance';
-import typeof ReactFabricType from '../Renderer/shims/ReactFabric';
-import typeof ReactNativeType from '../Renderer/shims/ReactNative';
 import type {RootTag} from './RootTag';
 
 import {
@@ -18,158 +15,45 @@ import {
   onRecoverableError,
   onUncaughtError,
 } from '../../src/private/renderer/errorhandling/ErrorHandlers';
+import ReactFabric from '../Renderer/shims/ReactFabric';
 import * as React from 'react';
 
-let cachedFabricRenderer;
-let cachedPaperRenderer;
-
-function getFabricRenderer(): ReactFabricType {
-  if (cachedFabricRenderer == null) {
-    cachedFabricRenderer = require('../Renderer/shims/ReactFabric').default;
-  }
-  return cachedFabricRenderer;
-}
-
-function getPaperRenderer(): ReactNativeType {
-  if (cachedPaperRenderer == null) {
-    cachedPaperRenderer = require('../Renderer/shims/ReactNative').default;
-  }
-  return cachedPaperRenderer;
-}
-
-const getMethod: (<MethodName: keyof ReactFabricType>(
-  () => ReactFabricType,
-  MethodName,
-) => ReactFabricType[MethodName]) &
-  (<MethodName: keyof ReactNativeType>(
-    () => ReactNativeType,
-    MethodName,
-  ) => ReactNativeType[MethodName]) = (getRenderer, methodName) => {
-  let cachedImpl;
-
-  // $FlowExpectedError[incompatible-type]
-  return function (arg1, arg2, arg3, arg4, arg5, arg6) {
-    if (cachedImpl == null) {
-      // $FlowExpectedError[prop-missing]
-      cachedImpl = getRenderer()[methodName];
-    }
-
-    // $FlowExpectedError[extra-arg]
-    return cachedImpl(arg1, arg2, arg3, arg4, arg5);
-  };
-};
-
-function getFabricMethod<MethodName: keyof ReactFabricType>(
-  methodName: MethodName,
-): ReactFabricType[MethodName] {
-  return getMethod(getFabricRenderer, methodName);
-}
-
-function getPaperMethod<MethodName: keyof ReactNativeType>(
-  methodName: MethodName,
-): ReactNativeType[MethodName] {
-  return getMethod(getPaperRenderer, methodName);
-}
-
-let cachedFabricRender;
-let cachedPaperRender;
-
 export function renderElement({
   element,
   rootTag,
-  useFabric,
-  useConcurrentRoot,
 }: {
   element: React.MixedElement,
-  rootTag: number,
-  useFabric: boolean,
-  useConcurrentRoot: boolean,
+  rootTag: RootTag,
 }): void {
-  if (useFabric) {
-    if (cachedFabricRender == null) {
-      cachedFabricRender = getFabricRenderer().render;
-    }
-
-    cachedFabricRender(element, rootTag, null, useConcurrentRoot, {
+  ReactFabric.render(
+    element,
+    Number(rootTag),
+    /* callback */ null,
+    /* useConcurrentRoot */ true,
+    {
       onCaughtError,
       onUncaughtError,
       onRecoverableError,
-    });
-  } else {
-    if (cachedPaperRender == null) {
-      cachedPaperRender = getPaperRenderer().render;
-    }
-
-    cachedPaperRender(element, rootTag, undefined, {
-      onCaughtError,
-      onUncaughtError,
-      onRecoverableError,
-    });
-  }
+    },
+  );
 }
 
-let cachedFabricDispatchCommand;
-let cachedPaperDispatchCommand;
-
-export function dispatchCommand(
-  handle: HostInstance,
-  command: string,
-  args: Array<unknown>,
-): void {
-  if (global.RN$Bridgeless === true) {
-    // Note: this function has the same implementation in the legacy and new renderer.
-    // However, evaluating the old renderer comes with some side effects.
-    if (cachedFabricDispatchCommand == null) {
-      cachedFabricDispatchCommand = getFabricRenderer().dispatchCommand;
-    }
-
-    return cachedFabricDispatchCommand(handle, command, args);
-  } else {
-    if (cachedPaperDispatchCommand == null) {
-      cachedPaperDispatchCommand = getPaperRenderer().dispatchCommand;
-    }
-
-    return cachedPaperDispatchCommand(handle, command, args);
-  }
-}
-
-export const findHostInstance_DEPRECATED: <TElementType: React.ElementType>(
-  // $FlowExpectedError[incompatible-type]
-  componentOrHandle: ?(React.ElementRef<TElementType> | number),
-) => ?HostInstance = getPaperMethod('findHostInstance_DEPRECATED');
-
-export const findNodeHandle: <TElementType: React.ElementType>(
-  // $FlowExpectedError[incompatible-type]
-  componentOrHandle: ?(React.ElementRef<TElementType> | number),
-) => ?number = getPaperMethod('findNodeHandle');
-
-export const sendAccessibilityEvent: ReactNativeType['sendAccessibilityEvent'] =
-  getPaperMethod('sendAccessibilityEvent');
-
-/**
- * This method is used by AppRegistry to unmount a root when using the old
- * React Native renderer (Paper).
- */
-export const unmountComponentAtNodeAndRemoveContainer: (
-  rootTag: RootTag,
-) => void =
-  // $FlowExpectedError[incompatible-type]
-  getPaperMethod('unmountComponentAtNodeAndRemoveContainer');
-
-export const unstable_batchedUpdates: ReactNativeType['unstable_batchedUpdates'] =
-  getPaperMethod('unstable_batchedUpdates');
-
-export const isChildPublicInstance: ReactNativeType['isChildPublicInstance'] =
-  getPaperMethod('isChildPublicInstance');
-
-export const getNodeFromInternalInstanceHandle: ReactFabricType['getNodeFromInternalInstanceHandle'] =
-  getFabricMethod('getNodeFromInternalInstanceHandle');
-
-export const getPublicInstanceFromInternalInstanceHandle: ReactFabricType['getPublicInstanceFromInternalInstanceHandle'] =
-  getFabricMethod('getPublicInstanceFromInternalInstanceHandle');
-
-export const getPublicInstanceFromRootTag: ReactFabricType['getPublicInstanceFromRootTag'] =
-  getFabricMethod('getPublicInstanceFromRootTag');
+// NOTE: these cannot be combined into a single destructuring statement because
+// `flow-api-translator` (used by `yarn build-types` to generate the
+// open-source type definitions) does not support destructuring in variable
+// declarations.
+export const dispatchCommand = ReactFabric.dispatchCommand;
+export const findHostInstance_DEPRECATED =
+  ReactFabric.findHostInstance_DEPRECATED;
+export const findNodeHandle = ReactFabric.findNodeHandle;
+export const sendAccessibilityEvent = ReactFabric.sendAccessibilityEvent;
+export const isChildPublicInstance = ReactFabric.isChildPublicInstance;
+export const getNodeFromInternalInstanceHandle =
+  ReactFabric.getNodeFromInternalInstanceHandle;
+export const getPublicInstanceFromInternalInstanceHandle =
+  ReactFabric.getPublicInstanceFromInternalInstanceHandle;
+export const getPublicInstanceFromRootTag =
+  ReactFabric.getPublicInstanceFromRootTag;
 
 export function isProfilingRenderer(): boolean {
   return Boolean(__DEV__);

package/Libraries/ReactNative/RendererProxy.js

@@ -8,19 +8,8 @@
  * @format
  */
 
-/**
- * This module exists to allow apps to select their renderer implementation
- * (e.g.: Fabric-only, Paper-only) without having to pull all the renderer
- * implementations into their app bundle, which affects app size.
- *
- * By default, the setup will be:
- *   -> RendererProxy
- *     -> RendererImplementation (which uses Fabric or Paper depending on a flag at runtime)
- *
- * But this will allow a setup like this without duplicating logic:
- *   -> RendererProxy (fork)
- *     -> RendererImplementation (which uses Fabric or Paper depending on a flag at runtime)
- *     or -> OtherImplementation (which uses Fabric only)
- */
-
+// This module allows app bundles to set up the appropriate Fabric renderer
+// variant (e.g., profiling vs production) before React Native is initialized.
+// The internal implementation (RendererProxy.fb.js) provides the indirection
+// needed to swap the renderer implementation at runtime.
 export * from './RendererImplementation';

package/Libraries/ReactNative/renderApplication.js

@@ -4,65 +4,63 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow
+ * @flow strict-local
  * @format
  */
 
 import type {ViewStyleProp} from '../StyleSheet/StyleSheet';
-import type {IPerformanceLogger} from '../Utilities/createPerformanceLogger';
+import type {RootTag} from './RootTag';
 
-import GlobalPerformanceLogger from '../Utilities/GlobalPerformanceLogger';
-import PerformanceLoggerContext from '../Utilities/PerformanceLoggerContext';
-import warnOnce from '../Utilities/warnOnce';
 import AppContainer from './AppContainer';
 import DisplayMode, {type DisplayModeType} from './DisplayMode';
 import getCachedComponentWithDebugName from './getCachedComponentWithDebugName';
 import * as Renderer from './RendererProxy';
+import {createRootTag} from './RootTag';
 import invariant from 'invariant';
 import * as React from 'react';
 
 // require BackHandler so it sets the default handler that exits the app if no listeners respond
 import '../Utilities/BackHandler';
 
-type ActivityType = component(
-  ...{
-    mode: 'visible' | 'hidden',
-    children: React.Node,
-  }
-);
+type ActivityType = component(mode: 'visible' | 'hidden', children: React.Node);
 
-export default function renderApplication<Props: Object>(
-  RootComponent: React.ComponentType<Props>,
+export type RenderApplicationOptions<Props extends {...}> = {
+  RootComponent: component(...Props),
   initialProps: Props,
-  rootTag: any,
-  WrapperComponent?: ?React.ComponentType<any>,
+  rootTag: number | RootTag,
+  WrapperComponent?: ?component(initialProps: Props, children: React.Node),
   rootViewStyle?: ?ViewStyleProp,
-  fabric?: boolean,
-  scopedPerformanceLogger?: IPerformanceLogger,
   isLogBox?: boolean,
   debugName?: string,
   displayMode?: ?DisplayModeType,
   useOffscreen?: boolean,
-) {
-  invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
+};
 
-  const performanceLogger = scopedPerformanceLogger ?? GlobalPerformanceLogger;
+export default function renderApplication<Props extends {...}>({
+  RootComponent,
+  initialProps,
+  rootTag,
+  WrapperComponent,
+  rootViewStyle,
+  isLogBox,
+  debugName,
+  displayMode,
+  useOffscreen,
+}: RenderApplicationOptions<Props>) {
+  invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
 
   let renderable: React.MixedElement = (
-    <PerformanceLoggerContext.Provider value={performanceLogger}>
-      <AppContainer
-        rootTag={rootTag}
-        fabric={fabric}
-        WrapperComponent={WrapperComponent}
-        rootViewStyle={rootViewStyle}
-        initialProps={initialProps ?? Object.freeze({})}
-        internal_excludeLogBox={isLogBox}>
-        <RootComponent {...initialProps} rootTag={rootTag} />
-      </AppContainer>
-    </PerformanceLoggerContext.Provider>
+    <AppContainer
+      rootTag={rootTag}
+      WrapperComponent={WrapperComponent}
+      rootViewStyle={rootViewStyle}
+      initialProps={initialProps ?? Object.freeze({})}
+      internal_excludeLogBox={isLogBox}>
+      <RootComponent {...initialProps} rootTag={rootTag} />
+    </AppContainer>
   );
 
-  if (__DEV__ && debugName) {
+  if (__DEV__ && debugName != null) {
     const RootComponentWithMeaningfulName = getCachedComponentWithDebugName(
       `${debugName}(RootComponent)`,
     );
@@ -73,10 +71,10 @@ export default function renderApplication<Props: Object>(
     );
   }
 
-  if (useOffscreen && displayMode != null) {
+  if (useOffscreen === true && displayMode != null) {
     // $FlowFixMe[incompatible-type]
-    // $FlowFixMe[prop-missing]
     // $FlowFixMe[missing-export]
+    // $FlowFixMe[prop-missing] `unstable_Activity` is not yet in the React types.
     const Activity: ActivityType = React.unstable_Activity;
 
     renderable = (
@@ -87,32 +85,8 @@ export default function renderApplication<Props: Object>(
     );
   }
 
-  // We want to have concurrentRoot always enabled when you're on Fabric.
-  const useConcurrentRoot = Boolean(fabric);
-
-  performanceLogger.startTimespan('renderApplication_React_render');
-  performanceLogger.setExtra(
-    'usedReactConcurrentRoot',
-    useConcurrentRoot ? '1' : '0',
-  );
-  performanceLogger.setExtra('usedReactFabric', fabric ? '1' : '0');
-  performanceLogger.setExtra(
-    'usedReactProfiler',
-    Renderer.isProfilingRenderer(),
-  );
   Renderer.renderElement({
     element: renderable,
-    rootTag,
-    useFabric: Boolean(fabric),
-    useConcurrentRoot,
+    rootTag: createRootTag(rootTag),
   });
-
-  const newArchitecture = !!fabric;
-  if (!newArchitecture) {
-    warnOnce(
-      '[OSS][OldArchDeprecatedWarning]',
-      'The app is running using the Legacy Architecture. The Legacy Architecture is deprecated and will be removed in a future version of React Native. Please consider migrating to the New Architecture. For more information, please see https://reactnative.dev/blog/2024/10/23/the-new-architecture-is-here',
-    );
-  }
-  performanceLogger.stopTimespan('renderApplication_React_render');
 }

package/Libraries/ReactNative/requireNativeComponent.js

@@ -26,11 +26,11 @@ const getNativeComponentAttributes =
  *
  */
 
-const requireNativeComponent = <T: {...}>(
+const requireNativeComponent = <T extends {...}>(
   uiViewClassName: string,
 ): HostComponent<T> =>
-  ((createReactNativeComponentClass(uiViewClassName, () =>
+  createReactNativeComponentClass(uiViewClassName, () =>
     getNativeComponentAttributes(uiViewClassName),
-  ): any): HostComponent<T>);
+  ) as any as HostComponent<T>;
 
 export default requireNativeComponent;

package/Libraries/ReactPrivate/ReactNativePrivateInterface.js

@@ -8,6 +8,7 @@
  * @format
  */
 
+import typeof dispatchNativeEvent from '../../src/private/renderer/events/dispatchNativeEvent';
 import typeof CustomEvent from '../../src/private/webapis/dom/events/CustomEvent';
 import typeof BatchedBridge from '../BatchedBridge/BatchedBridge';
 import typeof legacySendAccessibilityEvent from '../Components/AccessibilityInfo/legacySendAccessibilityEvent';
@@ -133,4 +134,8 @@ module.exports = {
     return require('../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance')
       .getInternalInstanceHandleFromPublicInstance;
   },
+  get dispatchNativeEvent(): dispatchNativeEvent {
+    return require('../../src/private/renderer/events/dispatchNativeEvent')
+      .default;
+  },
 };