react-native-tvos 0.86.2-0 → 0.87.0-0

package/src/private/webapis/dom/events/EventTarget.js

@@ -34,6 +34,7 @@ import {
   EVENT_TARGET_GET_DECLARATIVE_LISTENER_KEY,
   EVENT_TARGET_GET_THE_PARENT_KEY,
   INTERNAL_DISPATCH_METHOD_KEY,
+  getEventTargetParent,
 } from './internals/EventTargetInternals';
 
 export type EventCallback = (event: Event) => void;
@@ -54,9 +55,9 @@ export type AddEventListenerOptions = Readonly<{
 }>;
 
 type EventListenerRegistration = {
-  +callback: EventListener,
-  +passive: boolean,
-  +once: boolean,
+  readonly callback: EventListener,
+  readonly passive: boolean,
+  readonly once: boolean,
   removed: boolean,
 };
 
@@ -206,7 +207,7 @@ export default class EventTarget {
 
     setIsTrusted(event, false);
 
-    dispatch(this, event);
+    dispatch(this, event, false);
 
     return !event.defaultPrevented;
   }
@@ -217,10 +218,14 @@ export default class EventTarget {
    *
    * Called during event dispatch before explicitly registered listeners.
    * Return a callback to be invoked as an event listener, or null.
+   *
+   * `event.type` is the event type. `isCapture` distinguishes the capture pass
+   * from the bubble pass — it cannot be derived from `event.eventPhase`,
+   * which is `AT_TARGET` during both passes through the target node.
    */
   // $FlowExpectedError[unsupported-syntax]
   [EVENT_TARGET_GET_DECLARATIVE_LISTENER_KEY](
-    eventType: string,
+    event: Event,
     isCapture: boolean,
   ): EventCallback | null {
     return null;
@@ -239,14 +244,27 @@ export default class EventTarget {
   }
 
   /**
-   * This is "protected" method to dispatch trusted events.
+   * This is "protected" method to dispatch trusted events. Mirrors the
+   * `dispatchEvent` return contract: returns `false` if the event was
+   * canceled (i.e. `event.defaultPrevented`), otherwise `true`.
    */
   // $FlowExpectedError[unsupported-syntax]
-  [INTERNAL_DISPATCH_METHOD_KEY](event: Event): void {
-    dispatch(this, event);
+  [INTERNAL_DISPATCH_METHOD_KEY](
+    event: Event,
+    rethrowListenerErrors?: boolean,
+  ): boolean {
+    dispatch(this, event, rethrowListenerErrors === true);
+    return !event.defaultPrevented;
   }
 }
 
+// $FlowFixMe[cannot-write]
+Object.defineProperties(EventTarget.prototype, {
+  addEventListener: {enumerable: true},
+  removeEventListener: {enumerable: true},
+  dispatchEvent: {enumerable: true},
+});
+
 setPlatformObject(EventTarget);
 
 function validateCallback(callback: EventListener, methodName: string): void {
@@ -272,13 +290,26 @@ function getDefaultPassiveValue(
  * Implements the "event dispatch" concept
  * (see https://dom.spec.whatwg.org/#concept-event-dispatch).
  */
-function dispatch(eventTarget: EventTarget, event: Event): void {
+function dispatch(
+  eventTarget: EventTarget,
+  event: Event,
+  rethrowErrors: boolean,
+): void {
   setEventDispatchFlag(event, true);
 
   const eventPath = getEventPath(eventTarget, event);
   setComposedPath(event, eventPath);
   setTarget(event, eventTarget);
 
+  // When `rethrowErrors` is set (trusted dispatch of native UI events), collect
+  // the first listener error and rethrow it synchronously once the dispatch
+  // completes, matching the legacy plugin system's `rethrowCaughtError`
+  // behavior. Otherwise (the public `dispatchEvent` API, XHR, etc.) listener
+  // errors are reported to the global error handler per the DOM spec.
+  const errorState: ListenerErrorState | null = rethrowErrors
+    ? {hasError: false, error: undefined}
+    : null;
+
   for (let i = eventPath.length - 1; i >= 0; i--) {
     if (getStopPropagationFlag(event)) {
       break;
@@ -289,7 +320,7 @@ function dispatch(eventTarget: EventTarget, event: Event): void {
       event,
       target === eventTarget ? Event.AT_TARGET : Event.CAPTURING_PHASE,
     );
-    invoke(target, event, Event.CAPTURING_PHASE);
+    invoke(target, event, Event.CAPTURING_PHASE, errorState);
   }
 
   for (const target of eventPath) {
@@ -307,7 +338,7 @@ function dispatch(eventTarget: EventTarget, event: Event): void {
       event,
       target === eventTarget ? Event.AT_TARGET : Event.BUBBLING_PHASE,
     );
-    invoke(target, event, Event.BUBBLING_PHASE);
+    invoke(target, event, Event.BUBBLING_PHASE, errorState);
   }
 
   setEventPhase(event, Event.NONE);
@@ -317,6 +348,12 @@ function dispatch(eventTarget: EventTarget, event: Event): void {
   setEventDispatchFlag(event, false);
   setStopImmediatePropagationFlag(event, false);
   setStopPropagationFlag(event, false);
+
+  // Trusted dispatch: surface the first listener error synchronously, after the
+  // event has been fully cleaned up.
+  if (errorState != null && errorState.hasError) {
+    throw errorState.error;
+  }
 }
 
 /**
@@ -334,8 +371,7 @@ function getEventPath(
 
   while (target != null) {
     path.push(target);
-    // $FlowExpectedError[prop-missing]
-    target = target[EVENT_TARGET_GET_THE_PARENT_KEY]();
+    target = getEventTargetParent(target);
   }
 
   return path;
@@ -349,32 +385,44 @@ function invoke(
   eventTarget: EventTarget,
   event: Event,
   eventPhase: EventPhase,
+  errorState: ListenerErrorState | null,
 ) {
   const isCapture = eventPhase === Event.CAPTURING_PHASE;
 
   setCurrentTarget(event, eventTarget);
 
-  // Build the list of listeners to invoke:
-  // When the flag is enabled, prop-based listeners fire first, then
-  // explicitly registered addEventListener listeners.
-  // When disabled, only addEventListener listeners are used (legacy path).
-  let listeners: Array<EventListenerRegistration>;
-
   if (ReactNativeFeatureFlags.enableNativeEventTargetEventDispatching()) {
+    // Resolve the prop-based listener. Pass the event so subclasses can read
+    // its `type` and any pre-resolved internal slots; pass `isCapture`
+    // separately because it can't be derived from `event.eventPhase` (which
+    // is `AT_TARGET` during both passes through the target node).
     // $FlowExpectedError[prop-missing]
     const propListener: EventCallback | null = eventTarget[
       EVENT_TARGET_GET_DECLARATIVE_LISTENER_KEY
-    ](event.type, isCapture);
+    ](event, isCapture);
 
     const listenersByType = getListenersForPhase(eventTarget, isCapture);
     const maybeListeners = listenersByType?.get(event.type);
 
-    if (propListener == null && maybeListeners == null) {
+    // Fast path: only a prop listener (no `addEventListener` listeners).
+    // This is the overwhelmingly common case for React-driven dispatch.
+    if (maybeListeners == null) {
+      if (propListener == null) {
+        return;
+      }
+      const currentEvent = global.event;
+      global.event = event;
+      try {
+        propListener.call(eventTarget, event);
+      } catch (error) {
+        handleListenerError(error, errorState);
+      }
+      global.event = currentEvent;
       return;
     }
 
-    listeners = [];
-
+    // Slow path: combine prop listener + addEventListener listeners.
+    const listeners: Array<EventListenerRegistration> = [];
     if (propListener != null) {
       listeners.push({
         callback: propListener,
@@ -383,21 +431,35 @@ function invoke(
         removed: false,
       });
     }
-
-    if (maybeListeners != null) {
-      for (const registration of maybeListeners.values()) {
-        listeners.push(registration);
-      }
-    }
-  } else {
-    const listenersByType = getListenersForPhase(eventTarget, isCapture);
-    const maybeListeners = listenersByType?.get(event.type);
-    if (maybeListeners == null) {
-      return;
+    for (const registration of maybeListeners.values()) {
+      listeners.push(registration);
     }
-    listeners = Array.from(maybeListeners.values());
+    invokeListeners(eventTarget, event, listeners, isCapture, errorState);
+    return;
   }
 
+  // Legacy path (flag OFF): only `addEventListener` listeners.
+  const listenersByType = getListenersForPhase(eventTarget, isCapture);
+  const maybeListeners = listenersByType?.get(event.type);
+  if (maybeListeners == null) {
+    return;
+  }
+  invokeListeners(
+    eventTarget,
+    event,
+    Array.from(maybeListeners.values()),
+    isCapture,
+    errorState,
+  );
+}
+
+function invokeListeners(
+  eventTarget: EventTarget,
+  event: Event,
+  listeners: Array<EventListenerRegistration>,
+  isCapture: boolean,
+  errorState: ListenerErrorState | null,
+): void {
   for (const listener of listeners) {
     if (listener.removed) {
       continue;
@@ -424,8 +486,7 @@ function invoke(
         callback.handleEvent(event);
       }
     } catch (error) {
-      // TODO: replace with `reportError` when it's available.
-      console.error(error);
+      handleListenerError(error, errorState);
     }
 
     if (listener.passive) {
@@ -479,3 +540,51 @@ function setEventDispatchFlag(event: Event, value: boolean): void {
   // $FlowExpectedError[prop-missing]
   event[EVENT_DISPATCH_FLAG] = value;
 }
+
+type ListenerErrorState = {hasError: boolean, error: unknown};
+
+/**
+ * Handle an error thrown by an event listener without aborting the rest of the
+ * dispatch.
+ *
+ * For trusted dispatch of native UI events (`errorState` is non-null), the
+ * first error is recorded so `dispatch` can rethrow it synchronously once the
+ * dispatch completes, matching the legacy plugin path (React's
+ * runEventsInBatch + `rethrowCaughtError`). This keeps listener errors
+ * catchable by React error boundaries and the native event call, instead of
+ * escaping as deferred uncaught exceptions.
+ *
+ * Otherwise (`errorState` is null: the public `dispatchEvent` API, XHR, etc.)
+ * the DOM spec requires reporting the exception to the global error handler
+ * without throwing, so it is deferred via `reportListenerError`.
+ */
+function handleListenerError(
+  error: unknown,
+  errorState: ListenerErrorState | null,
+): void {
+  if (errorState != null) {
+    if (!errorState.hasError) {
+      errorState.hasError = true;
+      errorState.error = error;
+    }
+    return;
+  }
+
+  reportListenerError(error);
+}
+
+/**
+ * Surface a listener error to the global error handler without aborting the
+ * rest of the dispatch. Throws in a new task so the error becomes an uncaught
+ * exception. Used for dispatches that follow the DOM `dispatchEvent` contract
+ * (the public API, XHR, etc.), where errors are reported rather than thrown
+ * synchronously.
+ *
+ * `setTimeout(0)` schedules a new macrotask; the throw inside it has no
+ * catcher above, so it bubbles up to the host's unhandled-error reporter.
+ */
+function reportListenerError(error: unknown): void {
+  setTimeout(() => {
+    throw error;
+  }, 0);
+}

package/src/private/webapis/dom/events/internals/EventInternals.js

@@ -35,6 +35,42 @@ export const TARGET_KEY: symbol = Symbol('target');
 // platform using the original timestamps.
 export const EVENT_INIT_TIMESTAMP_KEY: symbol = Symbol('eventInitTimestamp');
 
+// Internal slots used by the React Native renderer to pass pre-resolved
+// React prop names ("onPointerUp" / "onPointerUpCapture") through the event
+// to subclasses of `EventTarget` (i.e. `ReactNativeElement`). This avoids
+// recomputing `getEventTypePropName(event.type, isCapture)` per ancestor per
+// phase during dispatch, which is hot.
+export const BUBBLED_PROP_NAME_KEY: symbol = Symbol('bubbledPropName');
+export const CAPTURED_PROP_NAME_KEY: symbol = Symbol('capturedPropName');
+
+export function getBubbledPropName(event: Event): string | null | void {
+  // $FlowExpectedError[prop-missing]
+  return event[BUBBLED_PROP_NAME_KEY];
+}
+
+export function setBubbledPropName(
+  event: Event,
+  propName: string | null,
+): void {
+  // $FlowExpectedError[prop-missing]
+  // $FlowExpectedError[invalid-computed-prop]
+  event[BUBBLED_PROP_NAME_KEY] = propName;
+}
+
+export function getCapturedPropName(event: Event): string | null | void {
+  // $FlowExpectedError[prop-missing]
+  return event[CAPTURED_PROP_NAME_KEY];
+}
+
+export function setCapturedPropName(
+  event: Event,
+  propName: string | null,
+): void {
+  // $FlowExpectedError[prop-missing]
+  // $FlowExpectedError[invalid-computed-prop]
+  event[CAPTURED_PROP_NAME_KEY] = propName;
+}
+
 export function getCurrentTarget(event: Event): EventTarget | null {
   // $FlowExpectedError[prop-missing]
   return event[CURRENT_TARGET_KEY];

package/src/private/webapis/dom/events/internals/EventTargetInternals.js

@@ -47,18 +47,53 @@ export const INTERNAL_DISPATCH_METHOD_KEY: symbol = Symbol(
   'EventTarget[dispatch]',
 );
 
+const EVENT_DISPATCH_PARENT_CACHE_KEY: symbol = Symbol(
+  'EventTarget[dispatch parent cache]',
+);
+
+export function getEventTargetParent(target: EventTarget): EventTarget | null {
+  // The slot is `undefined` until populated; a populated slot may hold
+  // `null` (no parent), so check against `undefined` rather than nullishness.
+  // $FlowExpectedError[prop-missing] symbol-keyed slot
+  const cached: EventTarget | null | void =
+    // $FlowExpectedError[prop-missing] symbol-keyed slot
+    target[EVENT_DISPATCH_PARENT_CACHE_KEY];
+  if (cached !== undefined) {
+    return cached;
+  }
+  // $FlowExpectedError[prop-missing] symbol-keyed method
+  const parent: EventTarget | null = target[EVENT_TARGET_GET_THE_PARENT_KEY]();
+  // $FlowExpectedError[prop-missing] symbol-keyed slot
+  target[EVENT_DISPATCH_PARENT_CACHE_KEY] = parent;
+  return parent;
+}
+
 /**
- * Dispatches a trusted event to the given event target.
+ * Dispatches a trusted event to the given event target. Mirrors the
+ * `dispatchEvent` method on `EventTarget`: returns `false` if the event
+ * was canceled (i.e. `event.defaultPrevented`), otherwise `true`.
  *
  * This should only be used by the runtime to dispatch native events to
  * JavaScript.
+ *
+ * When `rethrowListenerErrors` is `true`, the first error thrown by a listener
+ * is rethrown synchronously once dispatch completes (matching the legacy
+ * plugin system's `rethrowCaughtError` behavior). This is used by the renderer
+ * for native UI events so listener errors stay catchable by React error
+ * boundaries and the native event call. When omitted/`false`, listener errors
+ * are reported to the global error handler per the DOM spec (used by XHR and
+ * other web API event targets).
  */
 export function dispatchTrustedEvent(
   eventTarget: EventTarget,
   event: Event,
-): void {
+  rethrowListenerErrors?: boolean,
+): boolean {
   setIsTrusted(event, true);
 
   // $FlowExpectedError[prop-missing]
-  return eventTarget[INTERNAL_DISPATCH_METHOD_KEY](event);
+  return eventTarget[INTERNAL_DISPATCH_METHOD_KEY](
+    event,
+    rethrowListenerErrors,
+  );
 }

package/src/private/webapis/dom/nodes/ReactNativeDocument.js

@@ -139,3 +139,14 @@ export function createReactNativeDocument(
   const document = new ReactNativeDocument(rootTag, instanceHandle);
   return document;
 }
+
+export const ReactNativeDocument_public: typeof ReactNativeDocument =
+  // $FlowExpectedError[incompatible-type]
+  function Document() {
+    throw new TypeError(
+      "Failed to construct 'Document': Nodes cannot be imperatively created in React Native",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+ReactNativeDocument_public.prototype = ReactNativeDocument.prototype;

package/src/private/webapis/dom/nodes/ReactNativeElement.js

@@ -19,8 +19,8 @@ import type {
   MeasureInWindowOnSuccessCallback,
   MeasureLayoutOnSuccessCallback,
   MeasureOnSuccessCallback,
-  NativeMethods,
 } from '../../../types/HostInstance';
+import type Event from '../events/Event';
 import type {InstanceHandle} from './internals/NodeInternals';
 import type ReactNativeDocument from './ReactNativeDocument';
 
@@ -30,6 +30,10 @@ import {create as createAttributePayload} from '../../../../../Libraries/ReactNa
 import warnForStyleProps from '../../../../../Libraries/ReactNative/ReactFabricPublicInstance/warnForStyleProps';
 import * as ReactNativeFeatureFlags from '../../../featureflags/ReactNativeFeatureFlags';
 import {getEventTypePropName} from '../../../renderer/events/ReactNativeEventTypeMapping';
+import {
+  getBubbledPropName,
+  getCapturedPropName,
+} from '../events/internals/EventInternals';
 import {EVENT_TARGET_GET_DECLARATIVE_LISTENER_KEY} from '../events/internals/EventTargetInternals';
 import {
   getCurrentProps,
@@ -62,7 +66,8 @@ const noop = () => {};
 // was slower than this method because the engine has to create an object than
 // we then discard to create a new one.
 
-class ReactNativeElement extends ReadOnlyElement implements NativeMethods {
+/** @build-types protected-constructor */
+class ReactNativeElement extends ReadOnlyElement {
   // These need to be accessible from `ReactFabricPublicInstanceUtils`.
   __nativeTag: number;
   __internalInstanceHandle: InstanceHandle;
@@ -144,6 +149,9 @@ class ReactNativeElement extends ReadOnlyElement implements NativeMethods {
    * React Native compatibility methods
    */
 
+  /**
+   * Removes focus from an input or view. This is the opposite of `focus()`.
+   */
   blur(): void {
     if (TextInputState.isTextInput(this)) {
       TextInputState.blurTextInput(this);
@@ -152,6 +160,10 @@ class ReactNativeElement extends ReadOnlyElement implements NativeMethods {
     }
   }
 
+  /**
+   * Requests focus for the given input or view. The exact behavior triggered
+   * will depend on the platform and type of view.
+   */
   focus() {
     if (TextInputState.isTextInput(this)) {
       TextInputState.focusTextInput(this);
@@ -160,6 +172,23 @@ class ReactNativeElement extends ReadOnlyElement implements NativeMethods {
     }
   }
 
+  /**
+   * Determines the location on screen, width, and height of the given view and
+   * returns the values via an async callback. If successful, the callback will
+   * be called with the following arguments:
+   *
+   *  - x
+   *  - y
+   *  - width
+   *  - height
+   *  - pageX
+   *  - pageY
+   *
+   * Note that these measurements are not available until after the rendering
+   * has been completed in native. If you need the measurements as soon as
+   * possible, consider using the [`onLayout`
+   * prop](docs/view.html#onlayout) instead.
+   */
   measure(callback: MeasureOnSuccessCallback) {
     const node = getNativeElementReference(this);
     if (node != null) {
@@ -167,6 +196,21 @@ class ReactNativeElement extends ReadOnlyElement implements NativeMethods {
     }
   }
 
+  /**
+   * Determines the location of the given view in the window and returns the
+   * values via an async callback. If the React root view is embedded in
+   * another native view, this will give you the absolute coordinates. If
+   * successful, the callback will be called with the following
+   * arguments:
+   *
+   *  - x
+   *  - y
+   *  - width
+   *  - height
+   *
+   * Note that these measurements are not available until after the rendering
+   * has been completed in native.
+   */
   measureInWindow(callback: MeasureInWindowOnSuccessCallback) {
     const node = getNativeElementReference(this);
     if (node != null) {
@@ -174,6 +218,12 @@ class ReactNativeElement extends ReadOnlyElement implements NativeMethods {
     }
   }
 
+  /**
+   * Like [`measure()`](#measure), but measures the view relative an ancestor,
+   * specified as `relativeToNativeComponentRef`. This means that the returned x, y
+   * are relative to the origin x, y of the ancestor view.
+   * _Can also be called with a relativeNativeNodeHandle but is deprecated._
+   */
   measureLayout(
     relativeToNativeNode: number | HostInstance,
     onSuccess: MeasureLayoutOnSuccessCallback,
@@ -202,6 +252,12 @@ class ReactNativeElement extends ReadOnlyElement implements NativeMethods {
     }
   }
 
+  /**
+   * This function sends props straight to native. They will not participate in
+   * future diff process - this means that if you do not include them in the
+   * next render, they will remain active (see [Direct
+   * Manipulation](https://reactnative.dev/docs/the-new-architecture/direct-manipulation-new-architecture)).
+   */
   setNativeProps(nativeProps: {...}): void {
     if (__DEV__) {
       warnForStyleProps(nativeProps, this.__viewConfig.validAttributes);
@@ -223,16 +279,29 @@ class ReactNativeElement extends ReadOnlyElement implements NativeMethods {
   // This is called by EventTarget.invoke() before explicit addEventListener
   // listeners, allowing prop-based handlers to be resolved at dispatch time
   // without registering them via addEventListener during commit.
+  //
+  // Fast path: when `event` is a `LegacySyntheticEvent` (always the case for
+  // events created by `dispatchNativeEvent`), the React prop names have been
+  // pre-resolved on the event during construction. Reading them directly
+  // avoids the `getEventTypePropName(eventType, isCapture)` hash lookup per
+  // ancestor per phase.
   // $FlowExpectedError[unsupported-syntax]
   [EVENT_TARGET_GET_DECLARATIVE_LISTENER_KEY](
-    eventType: string,
+    event: Event,
     isCapture: boolean,
   ): ((event: Event) => void) | null {
     const currentProps = getCurrentProps(this);
     if (currentProps == null) {
       return null;
     }
-    const propName = getEventTypePropName(eventType, isCapture);
+    let propName = isCapture
+      ? getCapturedPropName(event)
+      : getBubbledPropName(event);
+    if (propName === undefined) {
+      // The event wasn't created via `dispatchNativeEvent` (e.g.,
+      // user-dispatched). Fall back to the mapping table.
+      propName = getEventTypePropName(event.type, isCapture);
+    }
     if (propName == null) {
       return null;
     }
@@ -274,3 +343,35 @@ function replaceConstructorWithoutSuper(
 export default replaceConstructorWithoutSuper(
   ReactNativeElement,
 ) as typeof ReactNativeElement;
+
+export const ReactNativeElement_public: typeof ReactNativeElement =
+  // $FlowExpectedError[incompatible-type]
+  function HTMLElement() {
+    throw new TypeError(
+      "Failed to construct 'HTMLElement': Nodes cannot be imperatively created in React Native",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+ReactNativeElement_public.prototype = ReactNativeElement.prototype;
+
+// The public imperative EventTarget API (`addEventListener`,
+// `removeEventListener`, `dispatchEvent`) is only inherited by this final class
+// when `enableNativeEventTargetEventDispatching` is enabled (which makes
+// `ReadOnlyNode` extend `EventTarget`). Until that public API is finalized, it
+// is gated behind `enableImperativeEvents`: when that flag is off we remove
+// those methods from this final class. Native/internal event dispatch does not
+// rely on these public methods, so removing them is safe.
+if (
+  ReactNativeFeatureFlags.enableNativeEventTargetEventDispatching() &&
+  !ReactNativeFeatureFlags.enableImperativeEvents()
+) {
+  const prototype: interface {
+    addEventListener?: unknown,
+    removeEventListener?: unknown,
+    dispatchEvent?: unknown,
+  } = ReactNativeElement.prototype;
+  prototype.addEventListener = undefined;
+  prototype.removeEventListener = undefined;
+  prototype.dispatchEvent = undefined;
+}

package/src/private/webapis/dom/nodes/ReadOnlyCharacterData.js

@@ -70,3 +70,14 @@ export default class ReadOnlyCharacterData extends ReadOnlyNode {
     return data.slice(offset, offset + adjustedCount);
   }
 }
+
+export const ReadOnlyCharacterData_public: typeof ReadOnlyCharacterData =
+  // $FlowExpectedError[incompatible-type]
+  function CharacterData() {
+    throw new TypeError(
+      "Failed to construct 'CharacterData': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+ReadOnlyCharacterData_public.prototype = ReadOnlyCharacterData.prototype;

package/src/private/webapis/dom/nodes/ReadOnlyElement.js

@@ -245,3 +245,12 @@ export function getBoundingClientRect(
   // Empty rect if any of the above failed
   return new DOMRect(0, 0, 0, 0);
 }
+
+export const ReadOnlyElement_public: typeof ReadOnlyElement =
+  // $FlowExpectedError[incompatible-type]
+  function Element() {
+    throw new TypeError("Failed to construct 'Element': Illegal constructor");
+  };
+
+// $FlowExpectedError[prop-missing]
+ReadOnlyElement_public.prototype = ReadOnlyElement.prototype;