react-native-tvos 0.85.3-1 → 0.86.0-0

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

@@ -15,7 +15,10 @@ import type {InstanceHandle} from './internals/NodeInternals';
 import type ReactNativeDocument from './ReactNativeDocument';
 import type ReadOnlyElement from './ReadOnlyElement';
 
+import * as ReactNativeFeatureFlags from '../../../featureflags/ReactNativeFeatureFlags';
 import {setPlatformObject} from '../../webidl/PlatformObjects';
+import EventTarget from '../events/EventTarget';
+import {EVENT_TARGET_GET_THE_PARENT_KEY} from '../events/internals/EventTargetInternals';
 import {createNodeList} from '../oldstylecollections/NodeList';
 import {
   getNativeNodeReference,
@@ -26,18 +29,47 @@ import {
 } from './internals/NodeInternals';
 import NativeDOM from './specs/NativeDOM';
 
-export default class ReadOnlyNode {
+// $FlowFixMe[unsupported-variance-annotation]
+// $FlowFixMe[incompatible-type]
+const ReadOnlyNodeBase: typeof Object =
+  ReactNativeFeatureFlags.enableNativeEventTargetEventDispatching()
+    ? EventTarget
+    : // $FlowFixMe[incompatible-type]
+      Object;
+
+// Ideally, this class would be exported as-is, but calling super() in a
+// subclass is a very slow operation the way that Babel transforms it at
+// the moment.
+//
+// This is a very hot code path (ReadOnlyNode is a base class for all
+// ReactNativeElement instances, which are instantiated once per rendered
+// host component in the tree) and we can't regress performance here.
+//
+// The optimization we're doing is using an old-style function constructor,
+// where we're not required to use `super()`, and we make that constructor
+// extend this class so it inherits all the methods and it sets the class
+// hierarchy correctly.
+
+class ReadOnlyNode extends ReadOnlyNodeBase {
   constructor(
     instanceHandle: InstanceHandle,
     // This will be null for the document node itself.
     ownerDocument: ReactNativeDocument | null,
   ) {
+    super();
     // This constructor is inlined in `ReactNativeElement` so if you modify
     // this make sure that their implementation stays in sync.
     setOwnerDocument(this, ownerDocument);
     setInstanceHandle(this, instanceHandle);
   }
 
+  // Implement the "get the parent" algorithm for EventTarget.
+  // This enables event propagation (capture/bubble) through the node tree.
+  // $FlowExpectedError[unsupported-syntax]
+  [EVENT_TARGET_GET_THE_PARENT_KEY](): EventTarget | null {
+    return this.parentNode;
+  }
+
   get childNodes(): NodeList<ReadOnlyNode> {
     const childNodes = getChildNodes(this);
     return createNodeList(childNodes);
@@ -294,6 +326,43 @@ export default class ReadOnlyNode {
 
 setPlatformObject(ReadOnlyNode);
 
+type ReadOnlyNodeT = ReadOnlyNode;
+
+function replaceConstructorWithoutSuper(
+  ReadOnlyNodeClass: Class<ReadOnlyNodeT>,
+): Class<ReadOnlyNodeT> {
+  // Alternative constructor just implemented to provide a better performance than
+  // calling super() in the original class.
+  // eslint-disable-next-line no-shadow
+  function ReadOnlyNode(
+    this: ReadOnlyNodeT,
+    instanceHandle: InstanceHandle,
+    ownerDocument: ReactNativeDocument | null,
+  ) {
+    setOwnerDocument(this, ownerDocument);
+    setInstanceHandle(this, instanceHandle);
+  }
+
+  ReadOnlyNode.prototype = ReadOnlyNodeClass.prototype;
+
+  // Copy static properties (ELEMENT_NODE, DOCUMENT_NODE, TEXT_NODE,
+  // DOCUMENT_POSITION_*, etc.) so that external callers that import this
+  // constructor can still access them.
+  // $FlowFixMe[unsafe-object-assign]
+  // $FlowFixMe[not-an-object]
+  Object.assign(ReadOnlyNode, ReadOnlyNodeClass);
+
+  // $FlowExpectedError[incompatible-type]
+  return ReadOnlyNode;
+}
+
+export default replaceConstructorWithoutSuper(
+  ReadOnlyNode,
+) as typeof ReadOnlyNode;
+
+// Temporary type until we ship ReadOnlyNode extending EventTarget ungated.
+export type ReadOnlyNodeWithEventTarget = ReadOnlyNode & EventTarget;
+
 export function getChildNodes(
   node: ReadOnlyNode,
   filter?: (node: ReadOnlyNode) => boolean,

package/src/private/webapis/dom/nodes/internals/NodeInternals.js

@@ -162,6 +162,16 @@ export function getNativeElementReference(
   return getNodeFromInternalInstanceHandle(instanceHandle);
 }
 
+/**
+ * Returns the current props for a node managed by React.
+ * This accesses React internals (fiber.stateNode.canonical.currentProps).
+ */
+export function getCurrentProps(node: ReadOnlyNode): {[string]: unknown} {
+  const instanceHandle = getInstanceHandle(node);
+  // $FlowExpectedError[incompatible-use] instanceHandle is opaque
+  return instanceHandle?.stateNode?.canonical?.currentProps ?? {};
+}
+
 export function getNativeTextReference(
   node: ReadOnlyCharacterData,
 ): ?NativeTextReference {

package/src/private/webapis/dom/nodes/specs/NativeDOM.js

@@ -448,4 +448,4 @@ export interface RefinedSpec {
 //    might end up loading this but not using it.
 // 2. We lose automatic backwards compatibility checks because of this.
 // $FlowExpectedError[incompatible-type]
-export default (TurboModuleRegistry.get<Spec>('NativeDOMCxx'): RefinedSpec);
+export default TurboModuleRegistry.get<Spec>('NativeDOMCxx') as RefinedSpec;

package/src/private/webapis/idlecallbacks/specs/NativeIdleCallbacks.js

@@ -31,6 +31,6 @@ export interface Spec extends TurboModule {
   +cancelIdleCallback: (handle: IdleCallbackID) => void;
 }
 
-export default (TurboModuleRegistry.getEnforcing<Spec>(
+export default TurboModuleRegistry.getEnforcing<Spec>(
   'NativeIdleCallbacksCxx',
-): Spec);
+) as Spec;

package/src/private/webapis/intersectionobserver/internals/IntersectionObserverManager.js

@@ -26,7 +26,6 @@ import type IntersectionObserverEntry from '../IntersectionObserverEntry';
 import type {NativeIntersectionObserverToken} from '../specs/NativeIntersectionObserver';
 
 import * as Systrace from '../../../../../Libraries/Performance/Systrace';
-import warnOnce from '../../../../../Libraries/Utilities/warnOnce';
 import {
   getInstanceHandle,
   getNativeNodeReference,
@@ -123,7 +122,7 @@ export function observe({
   target: ReactNativeElement,
 }): boolean {
   if (NativeIntersectionObserver == null) {
-    warnNoNativeIntersectionObserver();
+    throwIfNoNativeIntersectionObserver();
     return false;
   }
 
@@ -187,7 +186,7 @@ export function unobserve(
   target: ReactNativeElement,
 ): void {
   if (NativeIntersectionObserver == null) {
-    warnNoNativeIntersectionObserver();
+    throwIfNoNativeIntersectionObserver();
     return;
   }
 
@@ -232,7 +231,7 @@ function notifyIntersectionObservers(): void {
 
 function doNotifyIntersectionObservers(): void {
   if (NativeIntersectionObserver == null) {
-    warnNoNativeIntersectionObserver();
+    throwIfNoNativeIntersectionObserver();
     return;
   }
 
@@ -283,9 +282,6 @@ function doNotifyIntersectionObservers(): void {
   }
 }
 
-function warnNoNativeIntersectionObserver() {
-  warnOnce(
-    'missing-native-intersection-observer',
-    'Missing native implementation of IntersectionObserver',
-  );
+function throwIfNoNativeIntersectionObserver() {
+  throw new Error('Missing native implementation of IntersectionObserver');
 }

package/src/private/webapis/intersectionobserver/specs/NativeIntersectionObserver.js

@@ -47,6 +47,6 @@ export interface Spec extends TurboModule {
   +takeRecords: () => ReadonlyArray<NativeIntersectionObserverEntry>;
 }
 
-export default (TurboModuleRegistry.get<Spec>(
+export default TurboModuleRegistry.get<Spec>(
   'NativeIntersectionObserverCxx',
-): ?Spec);
+) as ?Spec;

package/src/private/webapis/microtasks/specs/NativeMicrotasks.js

@@ -16,6 +16,6 @@ export interface Spec extends TurboModule {
   +queueMicrotask: (callback: () => unknown) => void;
 }
 
-export default (TurboModuleRegistry.getEnforcing<Spec>(
+export default TurboModuleRegistry.getEnforcing<Spec>(
   'NativeMicrotasksCxx',
-): Spec);
+) as Spec;

package/src/private/webapis/mutationobserver/specs/NativeMutationObserver.js

@@ -50,6 +50,6 @@ export interface Spec extends TurboModule {
   +takeRecords: () => ReadonlyArray<NativeMutationRecord>;
 }
 
-export default (TurboModuleRegistry.get<Spec>(
+export default TurboModuleRegistry.get<Spec>(
   'NativeMutationObserverCxx',
-): ?Spec);
+) as ?Spec;

package/src/private/webapis/performance/internals/RawPerformanceEntry.js

@@ -119,7 +119,7 @@ export function performanceEntryTypeToRaw(
       return RawPerformanceEntryTypeValues.RESOURCE;
     default:
       // Verify exhaustive check with Flow
-      (type: empty);
+      (type) as empty;
       throw new TypeError(
         `performanceEntryTypeToRaw: unexpected performance entry type received: ${type}`,
       );

package/src/private/webapis/performance/specs/NativePerformance.js

@@ -101,4 +101,4 @@ export interface Spec extends TurboModule {
   +clearEventCountsForTesting: () => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('NativePerformanceCxx'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('NativePerformanceCxx') as ?Spec;

package/src/private/webapis/structuredClone/structuredClone.js

@@ -217,7 +217,7 @@ export default function structuredClone<T>(value: T): T {
 
 const NON_SERIALIZABLE_OBJECT_KEY = Symbol('nonSerializableObject');
 
-function isNonSerializableObject<T: interface {}>(obj: T): boolean {
+function isNonSerializableObject<T extends interface {}>(obj: T): boolean {
   // $FlowExpectedError[invalid-in-lhs]
   return NON_SERIALIZABLE_OBJECT_KEY in obj;
 }

package/src/private/webapis/webidl/PlatformObjects.js

@@ -17,11 +17,11 @@ const CLONE_PLATFORM_OBJECT_KEY = Symbol('clonePlatformObject');
  * Optionally, it sets the clone function for that platform object, which is a
  * simplification of the serializable attribute of the Web interface.
  */
-export const setPlatformObject: (<T: interface {}>(
+export const setPlatformObject: (<T extends interface {}>(
   obj: Class<T>,
   options?: {clone: T => T},
 ) => void) &
-  (<T: interface {}>(obj: T, options?: {clone: T => T}) => void) =
+  (<T extends interface {}>(obj: T, options?: {clone: T => T}) => void) =
   function setPlatformObject(obj, options) {
     if (typeof obj === 'function') {
       // $FlowExpectedError[prop-missing]
@@ -43,7 +43,7 @@ export const setPlatformObject: (<T: interface {}>(
 /**
  * Indicates if the given object is a platform object.
  */
-export function isPlatformObject<T: interface {}>(obj: T): boolean {
+export function isPlatformObject<T extends interface {}>(obj: T): boolean {
   // $FlowExpectedError[invalid-in-lhs]
   return IS_PLATFORM_OBJECT_KEY in obj;
 }
@@ -51,7 +51,7 @@ export function isPlatformObject<T: interface {}>(obj: T): boolean {
 /**
  * Returns the clone function for the given platform object, if it was set.
  */
-export function getPlatformObjectClone<T: interface {}>(
+export function getPlatformObjectClone<T extends interface {}>(
   obj: T,
 ): (T => T) | void {
   // $FlowExpectedError[prop-missing]