react-native-tvos 0.87.1-1 → 0.88.0-0rc2

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

@@ -19,9 +19,7 @@ export opaque type NativeElementReference = ShadowNode;
 export opaque type NativeTextReference = ShadowNode;
 
 export type NativeNodeReference =
-  | NativeElementReference
-  | NativeTextReference
-  | RootTag;
+  NativeElementReference | NativeTextReference | RootTag;
 
 export type MeasureInWindowOnSuccessCallback = (
   x: number,
@@ -58,16 +56,16 @@ export interface Spec extends TurboModule {
 
   readonly getChildNodes: (
     nativeNodeReference: unknown /* NativeNodeReference */,
-  ) => ReadonlyArray<unknown> /* $ReadOnlyArray<InstanceHandle> */;
+  ) => ReadonlyArray<unknown>; /* $ReadOnlyArray<InstanceHandle> */
 
   readonly getElementById?: (
     nativeNodeReference: unknown /* NativeNodeReference */,
     id: string,
-  ) => unknown /* ?InstanceHandle */;
+  ) => unknown; /* ?InstanceHandle */
 
   readonly getParentNode: (
     nativeNodeReference: unknown /* NativeNodeReference */,
-  ) => unknown /* ?InstanceHandle */;
+  ) => unknown; /* ?InstanceHandle */
 
   readonly isConnected: (
     nativeNodeReference: unknown /* NativeNodeReference */,
@@ -79,24 +77,24 @@ export interface Spec extends TurboModule {
 
   readonly getBorderWidth: (
     nativeElementReference: unknown /* NativeElementReference */,
-  ) => ReadonlyArray<number> /* [topWidth: number, rightWidth: number, bottomWidth: number, leftWidth: number] */;
+  ) => ReadonlyArray<number>; /* [topWidth: number, rightWidth: number, bottomWidth: number, leftWidth: number] */
 
   readonly getBoundingClientRect: (
     nativeElementReference: unknown /* NativeElementReference */,
     includeTransform: boolean,
-  ) => ReadonlyArray<number> /* [x: number, y: number, width: number, height: number] */;
+  ) => ReadonlyArray<number>; /* [x: number, y: number, width: number, height: number] */
 
   readonly getInnerSize: (
     nativeElementReference: unknown /* NativeElementReference */,
-  ) => ReadonlyArray<number> /* [width: number, height: number] */;
+  ) => ReadonlyArray<number>; /* [width: number, height: number] */
 
   readonly getScrollPosition: (
     nativeElementReference: unknown /* NativeElementReference */,
-  ) => ReadonlyArray<number> /* [scrollLeft: number, scrollTop: number] */;
+  ) => ReadonlyArray<number>; /* [scrollLeft: number, scrollTop: number] */
 
   readonly getScrollSize: (
     nativeElementReference: unknown /* NativeElementReference */,
-  ) => ReadonlyArray<number> /* [scrollWidth: number, scrollHeight: number] */;
+  ) => ReadonlyArray<number>; /* [scrollWidth: number, scrollHeight: number] */
 
   readonly getTagName: (
     nativeElementReference: unknown /* NativeElementReference */,
@@ -127,7 +125,7 @@ export interface Spec extends TurboModule {
 
   readonly getOffset: (
     nativeElementReference: unknown /* NativeElementReference */,
-  ) => ReadonlyArray<unknown> /* [offsetParent: ?InstanceHandle, top: number, left: number] */;
+  ) => ReadonlyArray<unknown>; /* [offsetParent: ?InstanceHandle, top: number, left: number] */
 
   /*
    * Special methods to handle the root node.
@@ -136,7 +134,7 @@ export interface Spec extends TurboModule {
   readonly linkRootNode?: (
     rootTag: number /* RootTag */,
     instanceHandle: unknown /* InstanceHandle */,
-  ) => unknown /* ?NativeElementReference */;
+  ) => unknown; /* ?NativeElementReference */
 
   /**
    * Legacy layout APIs (for `ReactNativeElement`).

package/src/private/webapis/intersectionobserver/IntersectionObserver.js

@@ -323,7 +323,7 @@ function normalizeThreshold(
       return threshold
         .map(t => normalizeThresholdValue(t, 'threshold'))
         .map(t => t ?? 0)
-        .sort();
+        .sort((a, b) => a - b);
     } else if (defaultEmpty) {
       return [];
     } else {
@@ -359,7 +359,7 @@ function normalizeRootThreshold(
     const normalizedArr = rootThreshold
       .map(rt => normalizeThresholdValue(rt, 'rnRootThreshold'))
       .filter((rt): rt is number => rt != null)
-      .sort();
+      .sort((a, b) => a - b);
     return normalizedArr.length === 0 ? null : normalizedArr;
   }
 

package/src/private/webapis/performance/EventTiming.js

@@ -16,10 +16,7 @@ import type {
 } from './PerformanceEntry';
 
 import {PerformanceEntry} from './PerformanceEntry';
-import MaybeNativePerformance from './specs/NativePerformance';
-import nullthrows from 'nullthrows';
-
-const NativePerformance = nullthrows(MaybeNativePerformance);
+import NativePerformance from './specs/NativePerformance';
 
 export type PerformanceEventTimingJSON = {
   ...PerformanceEntryJSON,

package/src/private/webapis/performance/Performance.js

@@ -29,12 +29,10 @@ import {
   performanceEntryTypeToRaw,
   rawToPerformanceEntry,
 } from './internals/RawPerformanceEntry';
-import {getCurrentTimeStamp} from './internals/Utilities';
 import MemoryInfo from './MemoryInfo';
 import ReactNativeStartupTiming from './ReactNativeStartupTiming';
-import MaybeNativePerformance from './specs/NativePerformance';
+import NativePerformance from './specs/NativePerformance';
 import {PerformanceMark, PerformanceMeasure} from './UserTiming';
-import nullthrows from 'nullthrows';
 
 export type PerformanceMeasureOptions =
   | Readonly<{
@@ -56,13 +54,8 @@ export type PerformanceMeasureOptions =
 const ENTRY_TYPES_AVAILABLE_FROM_TIMELINE: ReadonlyArray<PerformanceEntryType> =
   ['mark', 'measure'];
 
-const NativePerformance = nullthrows(MaybeNativePerformance);
-
-const cachedReportMark = NativePerformance.reportMark;
-const cachedReportMeasure = NativePerformance.reportMeasure;
-const cachedGetMarkTime = NativePerformance.getMarkTime;
-const cachedNativeClearMarks = NativePerformance.clearMarks;
-const cachedNativeClearMeasures = NativePerformance.clearMeasures;
+const {now, reportMark, reportMeasure, getMarkTime, clearMarks, clearMeasures} =
+  NativePerformance;
 let cachedTimeOrigin: ?DOMHighResTimeStamp;
 
 const MARK_OPTIONS_REUSABLE_OBJECT: PerformanceMarkOptions = {
@@ -78,7 +71,7 @@ const MEASURE_OPTIONS_REUSABLE_OBJECT: PerformanceMeasureInit = {
 };
 
 const getMarkTimeForMeasure = (markName: string): number => {
-  const markTime = cachedGetMarkTime(markName);
+  const markTime = getMarkTime(markName);
   if (markTime == null) {
     throw new DOMException(
       `Failed to execute 'measure' on 'Performance': The mark '${markName}' does not exist.`,
@@ -147,12 +140,7 @@ export default class Performance {
    */
   get timeOrigin(): DOMHighResTimeStamp {
     if (cachedTimeOrigin == null) {
-      if (NativePerformance.timeOrigin) {
-        cachedTimeOrigin = NativePerformance?.timeOrigin();
-      } else {
-        // Very naive polyfill.
-        cachedTimeOrigin = Date.now() - getCurrentTimeStamp();
-      }
+      cachedTimeOrigin = NativePerformance.timeOrigin();
     }
 
     return cachedTimeOrigin;
@@ -202,7 +190,7 @@ export default class Performance {
         );
       }
     } else {
-      resolvedStartTime = getCurrentTimeStamp();
+      resolvedStartTime = now();
     }
 
     if (detail !== undefined) {
@@ -219,13 +207,13 @@ export default class Performance {
       MARK_OPTIONS_REUSABLE_OBJECT,
     );
 
-    cachedReportMark(resolvedMarkName, resolvedStartTime, entry);
+    reportMark(resolvedMarkName, resolvedStartTime, entry);
 
     return entry;
   }
 
   clearMarks(markName?: string): void {
-    cachedNativeClearMarks(markName);
+    clearMarks(markName);
   }
 
   measure(
@@ -347,7 +335,7 @@ export default class Performance {
             ) {
               resolvedDuration = resolvedEndTime - resolvedStartTime;
             } else {
-              resolvedDuration = getCurrentTimeStamp() - resolvedStartTime;
+              resolvedDuration = now() - resolvedStartTime;
             }
           }
 
@@ -364,7 +352,7 @@ export default class Performance {
             resolvedDuration =
               getMarkTimeForMeasure(endMark) - resolvedStartTime;
           } else {
-            resolvedDuration = getCurrentTimeStamp() - resolvedStartTime;
+            resolvedDuration = now() - resolvedStartTime;
           }
           break;
         }
@@ -375,7 +363,7 @@ export default class Performance {
             resolvedDuration =
               getMarkTimeForMeasure(endMark) - resolvedStartTime;
           } else {
-            resolvedDuration = getCurrentTimeStamp() - resolvedStartTime;
+            resolvedDuration = now() - resolvedStartTime;
           }
         }
       }
@@ -385,7 +373,7 @@ export default class Performance {
       if (endMark !== undefined) {
         resolvedDuration = getMarkTimeForMeasure(endMark) - resolvedStartTime;
       } else {
-        resolvedDuration = getCurrentTimeStamp() - resolvedStartTime;
+        resolvedDuration = now() - resolvedStartTime;
       }
     }
 
@@ -400,7 +388,7 @@ export default class Performance {
 
     const entry = new PerformanceMeasure(MEASURE_OPTIONS_REUSABLE_OBJECT);
 
-    cachedReportMeasure(
+    reportMeasure(
       resolvedMeasureName,
       resolvedStartTime,
       resolvedDuration,
@@ -411,14 +399,14 @@ export default class Performance {
   }
 
   clearMeasures(measureName?: string): void {
-    cachedNativeClearMeasures(measureName);
+    clearMeasures(measureName);
   }
 
   /**
    * Returns a double, measured in milliseconds.
    * https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
    */
-  now: () => DOMHighResTimeStamp = getCurrentTimeStamp;
+  now: () => DOMHighResTimeStamp = now;
 
   /**
    * An extension that allows to get back to JS all currently logged marks/measures

package/src/private/webapis/performance/PerformanceEntry.js

@@ -14,11 +14,7 @@ import {setPlatformObject} from '../webidl/PlatformObjects';
 
 export type DOMHighResTimeStamp = number;
 export type PerformanceEntryType =
-  | 'mark'
-  | 'measure'
-  | 'event'
-  | 'longtask'
-  | 'resource';
+  'mark' | 'measure' | 'event' | 'longtask' | 'resource';
 
 export type PerformanceEntryJSON = {
   name: string,

package/src/private/webapis/performance/PerformanceObserver.js

@@ -21,13 +21,11 @@ import {
   rawToPerformanceEntry,
   rawToPerformanceEntryType,
 } from './internals/RawPerformanceEntry';
-import MaybeNativePerformance from './specs/NativePerformance';
+import NativePerformance from './specs/NativePerformance';
 import nullthrows from 'nullthrows';
 
 export {PerformanceEntry} from './PerformanceEntry';
 
-const NativePerformance = nullthrows(MaybeNativePerformance);
-
 export class PerformanceObserverEntryList {
   #entries: PerformanceEntryList;
 

package/src/private/webapis/performance/UserTiming.js

@@ -18,8 +18,10 @@ import type {
   ExtensionTrackEntryPayload,
 } from './UserTimingExtensibility';
 
-import {getCurrentTimeStamp} from './internals/Utilities';
 import {PerformanceEntry} from './PerformanceEntry';
+import NativePerformance from './specs/NativePerformance';
+
+const {now} = NativePerformance;
 
 export type DetailType =
   | unknown
@@ -47,7 +49,7 @@ class PerformanceMarkTemplate extends PerformanceEntry {
   constructor(markName: string, markOptions?: PerformanceMarkOptions) {
     super('mark', {
       name: markName,
-      startTime: markOptions?.startTime ?? getCurrentTimeStamp(),
+      startTime: markOptions?.startTime ?? now(),
       duration: 0,
     });
 
@@ -73,7 +75,7 @@ export const PerformanceMark: typeof PerformanceMarkTemplate =
   ) {
     this.__entryType = 'mark';
     this.__name = markName;
-    this.__startTime = markOptions?.startTime ?? getCurrentTimeStamp();
+    this.__startTime = markOptions?.startTime ?? now();
     this.__duration = 0;
 
     this.__detail = markOptions?.detail ?? null;

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

@@ -57,7 +57,7 @@ export type PerformanceObserverInit = {
 
 export interface Spec extends TurboModule {
   readonly now: () => number;
-  readonly timeOrigin?: () => number;
+  readonly timeOrigin: () => number;
 
   readonly reportMark: (
     name: string,
@@ -107,4 +107,6 @@ export interface Spec extends TurboModule {
   readonly clearEventCountsForTesting: () => void;
 }
 
-export default TurboModuleRegistry.get<Spec>('NativePerformanceCxx') as ?Spec;
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'NativePerformanceCxx',
+) as Spec;

package/src/private/webapis/resizeobserver/ResizeObserver.js

@@ -0,0 +1,207 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type {ResizeObserverId} from './internals/ResizeObserverManager';
+import type ResizeObserverEntry from './ResizeObserverEntry';
+
+import ReactNativeElement from '../dom/nodes/ReactNativeElement';
+import {setPlatformObject} from '../webidl/PlatformObjects';
+import * as ResizeObserverManager from './internals/ResizeObserverManager';
+
+export type ResizeObserverCallback = (
+  entries: ReadonlyArray<ResizeObserverEntry>,
+  observer: ResizeObserver,
+) => unknown;
+
+/**
+ * Corresponds to the `box` option of `ResizeObserver#observe`.
+ * https://drafts.csswg.org/resize-observer/#resize-observer-box-options
+ */
+export type ResizeObserverBoxOptions =
+  'content-box' | 'border-box' | 'device-pixel-content-box';
+
+export interface ResizeObserverOptions {
+  box?: ResizeObserverBoxOptions;
+}
+
+/**
+ * The [`ResizeObserver`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver)
+ * interface of the Resize Observer API reports changes to the dimensions of
+ * an element's content or border box.
+ *
+ * `ResizeObserver` avoids infinite callback loops and cyclic dependencies
+ * that are often created when resizing via a callback function, as it only
+ * observes block and inline sizes on the content box or border box, as
+ * opposed to observing changes in pixels.
+ *
+ * You can add/remove multiple target elements to/from a single
+ * `ResizeObserver` instance.
+ */
+export default class ResizeObserver {
+  _callback: ResizeObserverCallback;
+  _observationTargets: Map<ReactNativeElement, ResizeObserverBoxOptions> =
+    new Map();
+  _resizeObserverId: ?ResizeObserverId;
+
+  constructor(callback: ResizeObserverCallback): void {
+    if (callback == null) {
+      throw new TypeError(
+        "Failed to construct 'ResizeObserver': 1 argument required, but only 0 present.",
+      );
+    }
+
+    if (typeof callback !== 'function') {
+      throw new TypeError(
+        "Failed to construct 'ResizeObserver': parameter 1 is not of type 'Function'.",
+      );
+    }
+
+    this._callback = callback;
+  }
+
+  /**
+   * Starts observing the specified `ReactNativeElement`.
+   * One observer has one set of observation targets, and each target can be
+   * observed using either the target's content box or its border box (as
+   * specified by the `box` option).
+   * To stop observing an element, call `ResizeObserver.unobserve()`.
+   */
+  observe(target: ReactNativeElement, options?: ResizeObserverOptions): void {
+    if (target == null) {
+      throw new TypeError(
+        "Failed to execute 'observe' on 'ResizeObserver': parameter 1 is null or undefined.",
+      );
+    }
+
+    if (!(target instanceof ReactNativeElement)) {
+      throw new TypeError(
+        "Failed to execute 'observe' on 'ResizeObserver': parameter 1 is not of type 'ReactNativeElement'.",
+      );
+    }
+
+    const box = normalizeBoxOption(options?.box);
+
+    if (this._observationTargets.has(target)) {
+      // Re-observing a target already observed with the SAME box is a no-op
+      // and does not re-deliver. This matches observed browser behavior.
+      const previousBox = this._observationTargets.get(target);
+      if (previousBox === box) {
+        return;
+      }
+
+      ResizeObserverManager.unobserve(
+        this._getOrCreateResizeObserverId(),
+        target,
+      );
+      this._observationTargets.delete(target);
+    }
+
+    const resizeObserverId = this._getOrCreateResizeObserverId();
+    const didObserve = ResizeObserverManager.observe({
+      resizeObserverId,
+      target,
+      box,
+    });
+
+    if (didObserve) {
+      this._observationTargets.set(target, box);
+    } else if (this._observationTargets.size === 0) {
+      // Target couldn't be observed (e.g. disconnected). Don't record it so a
+      // later `observe` can retry, and release the registration since nothing
+      // is observed.
+      ResizeObserverManager.unregisterObserver(resizeObserverId);
+      this._resizeObserverId = null;
+    }
+  }
+
+  /**
+   * Ends the observing of the specified `ReactNativeElement`.
+   */
+  unobserve(target: ReactNativeElement): void {
+    if (!(target instanceof ReactNativeElement)) {
+      throw new TypeError(
+        "Failed to execute 'unobserve' on 'ResizeObserver': parameter 1 is not of type 'ReactNativeElement'.",
+      );
+    }
+
+    if (!this._observationTargets.has(target)) {
+      return;
+    }
+
+    const resizeObserverId = this._resizeObserverId;
+    if (resizeObserverId == null) {
+      // This is unexpected if the target is in `_observationTargets`.
+      console.error(
+        "Unexpected state in 'ResizeObserver': could not find observer ID to unobserve target.",
+      );
+      return;
+    }
+
+    ResizeObserverManager.unobserve(resizeObserverId, target);
+    this._observationTargets.delete(target);
+
+    if (this._observationTargets.size === 0) {
+      ResizeObserverManager.unregisterObserver(resizeObserverId);
+      this._resizeObserverId = null;
+    }
+  }
+
+  /**
+   * Unobserves all observed `ReactNativeElement` targets.
+   */
+  disconnect(): void {
+    for (const target of this._observationTargets.keys()) {
+      this.unobserve(target);
+    }
+  }
+
+  _getOrCreateResizeObserverId(): ResizeObserverId {
+    let resizeObserverId = this._resizeObserverId;
+    if (resizeObserverId == null) {
+      resizeObserverId = ResizeObserverManager.registerObserver(
+        this,
+        this._callback,
+      );
+      this._resizeObserverId = resizeObserverId;
+    }
+    return resizeObserverId;
+  }
+
+  // Only for tests
+  __getObserverID(): ?ResizeObserverId {
+    return this._resizeObserverId;
+  }
+}
+
+setPlatformObject(ResizeObserver);
+
+function normalizeBoxOption(
+  box: ?ResizeObserverBoxOptions,
+): ResizeObserverBoxOptions {
+  if (box == null) {
+    return 'content-box';
+  }
+
+  if (
+    box !== 'content-box' &&
+    box !== 'border-box' &&
+    box !== 'device-pixel-content-box'
+  ) {
+    throw new TypeError(
+      `Failed to execute 'observe' on 'ResizeObserver': Failed to read the 'box' property from 'ResizeObserverOptions': The provided value '${String(
+        box,
+      )}' is not a valid enum value of type ResizeObserverBoxOptions.`,
+    );
+  }
+
+  return box;
+}

package/src/private/webapis/resizeobserver/ResizeObserverEntry.js

@@ -0,0 +1,146 @@
+/**
+ * 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
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type ReactNativeElement from '../dom/nodes/ReactNativeElement';
+import type {NativeResizeObserverEntry} from './specs/NativeResizeObserver';
+
+import DOMRectReadOnly from '../geometry/DOMRectReadOnly';
+import {setPlatformObject} from '../webidl/PlatformObjects';
+import ResizeObserverSize from './ResizeObserverSize';
+
+/**
+ * The [`ResizeObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry)
+ * interface of the Resize Observer API represents the object passed to the
+ * `ResizeObserver()` callback function, which allows access to the new
+ * dimensions of the observed target element after its size has changed.
+ */
+export default class ResizeObserverEntry {
+  // We lazily compute all the properties from the raw entry provided by the
+  // native module, so we avoid unnecessary work.
+  _nativeEntry: NativeResizeObserverEntry;
+  // There are cases where this cannot be safely derived from the instance
+  // handle in the native entry (when the target is detached), so we need to
+  // keep a reference to it directly.
+  _target: ReactNativeElement;
+  _contentRect: ?DOMRectReadOnly;
+  _borderBoxSize: ?ReadonlyArray<ResizeObserverSize>;
+  _contentBoxSize: ?ReadonlyArray<ResizeObserverSize>;
+  _devicePixelContentBoxSize: ?ReadonlyArray<ResizeObserverSize>;
+
+  constructor(
+    nativeEntry: NativeResizeObserverEntry,
+    target: ReactNativeElement,
+  ) {
+    this._nativeEntry = nativeEntry;
+    this._target = target;
+  }
+
+  /**
+   * The `ReactNativeElement` whose size has changed.
+   */
+  get target(): ReactNativeElement {
+    return this._target;
+  }
+
+  /**
+   * Returns a `DOMRectReadOnly` object which, prior to Firefox 57, contained
+   * the new size of the observed element.
+   *
+   * In React Native, this is the content rect of the observed target (the
+   * bounds of its content box).
+   */
+  get contentRect(): DOMRectReadOnly {
+    if (this._contentRect == null) {
+      const contentRect = this._nativeEntry.contentRect;
+      this._contentRect = new DOMRectReadOnly(
+        contentRect[0],
+        contentRect[1],
+        contentRect[2],
+        contentRect[3],
+      );
+    }
+    return this._contentRect;
+  }
+
+  /**
+   * An array containing the new border box size of the observed element.
+   *
+   * Note: React Native does not support fragments, so this array will
+   * always contain a single value.
+   */
+  get borderBoxSize(): ReadonlyArray<ResizeObserverSize> {
+    if (this._borderBoxSize == null) {
+      const borderBoxSize = this._nativeEntry.borderBoxSize;
+      this._borderBoxSize = Object.freeze([
+        new ResizeObserverSize(borderBoxSize[0], borderBoxSize[1]),
+      ]);
+    }
+    return this._borderBoxSize;
+  }
+
+  /**
+   * An array containing the new content box size of the observed element.
+   *
+   * Note: React Native does not support fragments, so this array will
+   * always contain a single value.
+   */
+  get contentBoxSize(): ReadonlyArray<ResizeObserverSize> {
+    if (this._contentBoxSize == null) {
+      const contentBoxSize = this._nativeEntry.contentBoxSize;
+      this._contentBoxSize = Object.freeze([
+        new ResizeObserverSize(contentBoxSize[0], contentBoxSize[1]),
+      ]);
+    }
+    return this._contentBoxSize;
+  }
+
+  /**
+   * An array containing the new device pixel content box size of the observed element.
+   *
+   * Note: React Native does not support fragments, so this array will
+   * always contain a single value.
+   */
+  get devicePixelContentBoxSize(): ReadonlyArray<ResizeObserverSize> {
+    if (this._devicePixelContentBoxSize == null) {
+      const devicePixelContentBoxSize =
+        this._nativeEntry.devicePixelContentBoxSize;
+      this._devicePixelContentBoxSize = Object.freeze([
+        new ResizeObserverSize(
+          devicePixelContentBoxSize[0],
+          devicePixelContentBoxSize[1],
+        ),
+      ]);
+    }
+    return this._devicePixelContentBoxSize;
+  }
+}
+
+setPlatformObject(ResizeObserverEntry);
+
+export function createResizeObserverEntry(
+  entry: NativeResizeObserverEntry,
+  target: ReactNativeElement,
+): ResizeObserverEntry {
+  return new ResizeObserverEntry(entry, target);
+}
+
+export const ResizeObserverEntry_public: typeof ResizeObserverEntry =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function ResizeObserverEntry() {
+    throw new TypeError(
+      "Failed to construct 'ResizeObserverEntry': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+ResizeObserverEntry_public.prototype = ResizeObserverEntry.prototype;