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

package/ReactCommon/yoga/yoga/style/GridStyle.h

@@ -0,0 +1,80 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include <yoga/style/GridLine.h>
+#include <yoga/style/GridTrack.h>
+
+namespace facebook::yoga {
+
+/**
+ * The CSS Grid properties of a single node.
+ */
+struct GridStyle {
+  // Grid container properties
+  GridTrackList templateColumns{};
+  GridTrackList templateRows{};
+  GridTrackList autoColumns{};
+  GridTrackList autoRows{};
+
+  // Grid item properties
+  GridLine columnStart{};
+  GridLine columnEnd{};
+  GridLine rowStart{};
+  GridLine rowEnd{};
+
+  bool operator==(const GridStyle& other) const = default;
+};
+
+/**
+ * Storage for a GridStyle which stays empty until the first grid property is
+ * set.
+ */
+class GridStyleStorage {
+ public:
+  GridStyleStorage() = default;
+  GridStyleStorage(GridStyleStorage&&) noexcept = default;
+  GridStyleStorage& operator=(GridStyleStorage&&) noexcept = default;
+
+  GridStyleStorage(const GridStyleStorage& other) {
+    *this = other;
+  }
+
+  GridStyleStorage& operator=(const GridStyleStorage& other) {
+    grid_ = other.grid_ == nullptr ? nullptr
+                                   : std::make_unique<GridStyle>(*other.grid_);
+    return *this;
+  }
+
+  const GridStyle& get() const {
+    return grid_ == nullptr ? defaults() : *grid_;
+  }
+
+  GridStyle& ensure() {
+    if (grid_ == nullptr) {
+      grid_ = std::make_unique<GridStyle>();
+    }
+    return *grid_;
+  }
+
+  bool operator==(const GridStyleStorage& other) const {
+    return grid_ == other.grid_ || get() == other.get();
+  }
+
+ private:
+  static const GridStyle& defaults() {
+    static const GridStyle kDefaults{};
+    return kDefaults;
+  }
+
+  std::unique_ptr<GridStyle> grid_{};
+};
+
+} // namespace facebook::yoga

package/ReactCommon/yoga/yoga/style/Style.h

@@ -30,6 +30,7 @@
 #include <yoga/enums/Wrap.h>
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/GridLine.h>
+#include <yoga/style/GridStyle.h>
 #include <yoga/style/GridTrack.h>
 #include <yoga/style/StyleLength.h>
 #include <yoga/style/StyleSizeLength.h>
@@ -209,84 +210,84 @@ class YG_EXPORT Style {
 
   // Grid Container Properties
   const GridTrackList& gridTemplateColumns() const {
-    return gridTemplateColumns_;
+    return grid_.get().templateColumns;
   }
   void setGridTemplateColumns(GridTrackList value) {
-    gridTemplateColumns_ = std::move(value);
+    grid_.ensure().templateColumns = std::move(value);
   }
   void resizeGridTemplateColumns(size_t count) {
-    gridTemplateColumns_.resize(count);
+    grid_.ensure().templateColumns.resize(count);
   }
   void setGridTemplateColumnAt(size_t index, GridTrackSize value) {
-    gridTemplateColumns_[index] = value;
+    grid_.ensure().templateColumns[index] = value;
   }
 
   const GridTrackList& gridTemplateRows() const {
-    return gridTemplateRows_;
+    return grid_.get().templateRows;
   }
   void setGridTemplateRows(GridTrackList value) {
-    gridTemplateRows_ = std::move(value);
+    grid_.ensure().templateRows = std::move(value);
   }
   void resizeGridTemplateRows(size_t count) {
-    gridTemplateRows_.resize(count);
+    grid_.ensure().templateRows.resize(count);
   }
   void setGridTemplateRowAt(size_t index, GridTrackSize value) {
-    gridTemplateRows_[index] = value;
+    grid_.ensure().templateRows[index] = value;
   }
 
   const GridTrackList& gridAutoColumns() const {
-    return gridAutoColumns_;
+    return grid_.get().autoColumns;
   }
   void setGridAutoColumns(GridTrackList value) {
-    gridAutoColumns_ = std::move(value);
+    grid_.ensure().autoColumns = std::move(value);
   }
   void resizeGridAutoColumns(size_t count) {
-    gridAutoColumns_.resize(count);
+    grid_.ensure().autoColumns.resize(count);
   }
   void setGridAutoColumnAt(size_t index, GridTrackSize value) {
-    gridAutoColumns_[index] = value;
+    grid_.ensure().autoColumns[index] = value;
   }
 
   const GridTrackList& gridAutoRows() const {
-    return gridAutoRows_;
+    return grid_.get().autoRows;
   }
   void setGridAutoRows(GridTrackList value) {
-    gridAutoRows_ = std::move(value);
+    grid_.ensure().autoRows = std::move(value);
   }
   void resizeGridAutoRows(size_t count) {
-    gridAutoRows_.resize(count);
+    grid_.ensure().autoRows.resize(count);
   }
   void setGridAutoRowAt(size_t index, GridTrackSize value) {
-    gridAutoRows_[index] = value;
+    grid_.ensure().autoRows[index] = value;
   }
 
   // Grid Item Properties
   const GridLine& gridColumnStart() const {
-    return gridColumnStart_;
+    return grid_.get().columnStart;
   }
   void setGridColumnStart(GridLine value) {
-    gridColumnStart_ = value;
+    grid_.ensure().columnStart = value;
   }
 
   const GridLine& gridColumnEnd() const {
-    return gridColumnEnd_;
+    return grid_.get().columnEnd;
   }
   void setGridColumnEnd(GridLine value) {
-    gridColumnEnd_ = value;
+    grid_.ensure().columnEnd = value;
   }
 
   const GridLine& gridRowStart() const {
-    return gridRowStart_;
+    return grid_.get().rowStart;
   }
   void setGridRowStart(GridLine value) {
-    gridRowStart_ = value;
+    grid_.ensure().rowStart = value;
   }
 
   const GridLine& gridRowEnd() const {
-    return gridRowEnd_;
+    return grid_.get().rowEnd;
   }
   void setGridRowEnd(GridLine value) {
-    gridRowEnd_ = value;
+    grid_.ensure().rowEnd = value;
   }
 
   FloatOptional resolvedMinDimension(
@@ -667,14 +668,7 @@ class YG_EXPORT Style {
         sizeLengthsEqual(
                maxDimensions_, pool_, other.maxDimensions_, other.pool_) &&
         numbersEqual(aspectRatio_, pool_, other.aspectRatio_, other.pool_) &&
-        gridTemplateColumns_ == other.gridTemplateColumns_ &&
-        gridTemplateRows_ == other.gridTemplateRows_ &&
-        gridAutoColumns_ == other.gridAutoColumns_ &&
-        gridAutoRows_ == other.gridAutoRows_ &&
-        gridColumnStart_ == other.gridColumnStart_ &&
-        gridColumnEnd_ == other.gridColumnEnd_ &&
-        gridRowStart_ == other.gridRowStart_ &&
-        gridRowEnd_ == other.gridRowEnd_;
+        grid_ == other.grid_;
   }
 
  private:
@@ -929,15 +923,8 @@ class YG_EXPORT Style {
   Dimensions maxDimensions_{};
   StyleValueHandle aspectRatio_{};
 
-  // Grid properties
-  GridTrackList gridTemplateColumns_{};
-  GridTrackList gridTemplateRows_{};
-  GridTrackList gridAutoColumns_{};
-  GridTrackList gridAutoRows_{};
-  GridLine gridColumnStart_{};
-  GridLine gridColumnEnd_{};
-  GridLine gridRowStart_{};
-  GridLine gridRowEnd_{};
+  // Grid properties, allocated only when one of them is set
+  GridStyleStorage grid_{};
 
   StyleValuePool pool_;
 };

package/cli.js

@@ -13,7 +13,7 @@
 
 // $FlowFixMe[untyped-import]
 const {name} = require('./package.json');
-const {styleText} = require('util');
+const {styleText} = require('node:util');
 
 const deprecated = () => {
   throw new Error(

package/flow/HermesInternalType.js

@@ -26,11 +26,11 @@ declare type $HermesInternalType = {
   // All members are optional because they may not exist when OTA'd to older
   // VMs.
 
-  +getNumGCs?: () => number,
-  +getGCTime?: () => number,
-  +getNativeCallTime?: () => number,
-  +getNativeCallCount?: () => number,
-  +getGCCPUTime?: () => number,
+  readonly getNumGCs?: () => number,
+  readonly getGCTime?: () => number,
+  readonly getNativeCallTime?: () => number,
+  readonly getNativeCallCount?: () => number,
+  readonly getGCCPUTime?: () => number,
 
   /**
    * Hermes can embed an "epilogue" to the bytecode file with arbitrary bytes.
@@ -39,7 +39,7 @@ declare type $HermesInternalType = {
    * Calling this function will return all such epilogues and convert the
    * bytes to numbers in the range of 0-255.
    */
-  +getEpilogues?: () => Array<Array<number>>,
+  readonly getEpilogues?: () => Array<Array<number>>,
 
   /**
    * Query the VM for various statistics about performance.
@@ -48,7 +48,7 @@ declare type $HermesInternalType = {
    * @return An object that maps strings to various types of performance
    *    statistics.
    */
-  +getInstrumentedStats?: () => {[string]: number | string, ...},
+  readonly getInstrumentedStats?: () => {[string]: number | string, ...},
 
   /**
    * Query the VM for any sort of runtime properties that it wants to report.
@@ -56,7 +56,7 @@ declare type $HermesInternalType = {
    * printed for informational purposes.
    * @return An object that maps strings to various types of runtime properties.
    */
-  +getRuntimeProperties?: () => {
+  readonly getRuntimeProperties?: () => {
     'OSS Release Version': string,
     Build: string,
     [string]: unknown,
@@ -69,7 +69,7 @@ declare type $HermesInternalType = {
    * This can be called several times but will have no effect after the first
    * call.
    */
-  +ttiReached?: () => void,
+  readonly ttiReached?: () => void,
 
   /**
    * Tell Hermes that at this point the surface has transitioned from TTRC to
@@ -78,12 +78,12 @@ declare type $HermesInternalType = {
    * This can be called several times but will have no effect after the first
    * call.
    */
-  +ttrcReached?: () => void,
+  readonly ttrcReached?: () => void,
 
   /**
    * Query the VM to see whether or not it enabled Promise.
    */
-  +hasPromise?: () => boolean,
+  readonly hasPromise?: () => boolean,
 
   /**
    * Enable promise rejection tracking with the given options.
@@ -91,7 +91,7 @@ declare type $HermesInternalType = {
    * the `enable` function of module `promise/setimmediate/rejection-tracking`
    * declared in ./flow-typed/npm/promise_v8.x.x.js.
    */
-  +enablePromiseRejectionTracker?: (
+  readonly enablePromiseRejectionTracker?: (
     options: ?{
       whitelist?: ?Array<unknown>,
       allRejections?: ?boolean,
@@ -103,12 +103,12 @@ declare type $HermesInternalType = {
   /**
    * Query the VM to see whether or not it use the engine Job queue.
    */
-  +useEngineQueue?: () => boolean,
+  readonly useEngineQueue?: () => boolean,
 
   /**
    * Enqueue a JavaScript callback function as a Job into the engine Job queue.
    */
-  +enqueueJob?: <TArguments extends Array<unknown>>(
+  readonly enqueueJob?: <TArguments extends Array<unknown>>(
     jobCallback: (...args: TArguments) => unknown,
   ) => void,
 };

package/flow/bom.js.flow

@@ -81,7 +81,6 @@ declare var console: {
 
   // Stack tagging
   createTask(label: string): ConsoleTask,
-
   ...
 };
 
@@ -419,6 +418,36 @@ declare class IntersectionObserver {
   unobserve(target: Element): void;
 }
 
+declare class ResizeObserverSize {
+  readonly blockSize: number;
+  readonly inlineSize: number;
+}
+
+declare class ResizeObserverEntry {
+  readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
+  readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
+  readonly contentRect: DOMRectReadOnly;
+  readonly devicePixelContentBoxSize: ReadonlyArray<ResizeObserverSize>;
+  readonly target: Element;
+}
+
+declare type ResizeObserverCallback = (
+  entries: ReadonlyArray<ResizeObserverEntry>,
+  observer: ResizeObserver,
+) => unknown;
+
+declare type ResizeObserverOptions = {
+  box?: 'content-box' | 'border-box' | 'device-pixel-content-box',
+  ...
+};
+
+declare class ResizeObserver {
+  constructor(callback: ResizeObserverCallback): void;
+  disconnect(): void;
+  observe(target: Element, options?: ResizeObserverOptions): void;
+  unobserve(target: Element): void;
+}
+
 declare class CloseEvent extends Event {
   code: number;
   reason: string;
@@ -515,9 +544,7 @@ declare class XMLHttpRequestEventTarget extends EventTarget {
 // this part of spec is not finished yet, apparently
 // https://stackoverflow.com/questions/35296664/can-fetch-get-object-as-headers
 type HeadersInit =
-  | Headers
-  | Array<[string, string]>
-  | {[key: string]: string, ...};
+  Headers | Array<[string, string]> | {[key: string]: string, ...};
 
 // TODO Heades and URLSearchParams are almost the same thing.
 // Could it somehow be abstracted away?
@@ -599,12 +626,7 @@ type ReferrerPolicyType =
   | 'unsafe-url';
 
 type ResponseType =
-  | 'basic'
-  | 'cors'
-  | 'default'
-  | 'error'
-  | 'opaque'
-  | 'opaqueredirect';
+  'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
 
 type BodyInit =
   | string

package/flow/cssom.js.flow

@@ -409,10 +409,7 @@ type AnimationPlayState = 'idle' | 'running' | 'paused' | 'finished';
 type AnimationReplaceState = 'active' | 'removed' | 'persisted';
 type FillMode = 'none' | 'forwards' | 'backwards' | 'both' | 'auto';
 type PlaybackDirection =
-  | 'normal'
-  | 'reverse'
-  | 'alternate'
-  | 'alternate-reverse';
+  'normal' | 'reverse' | 'alternate' | 'alternate-reverse';
 type IterationCompositeOperation = 'replace' | 'accumulate';
 type CompositeOperation = 'replace' | 'add' | 'accumulate';
 type CompositeOperationOrAuto = CompositeOperation | 'auto';
@@ -481,12 +478,7 @@ type PropertyIndexedKeyframes = {
   easing?: string | string[],
   offset?: number | (number | null)[],
   [property: string]:
-    | string
-    | string[]
-    | number
-    | null
-    | (number | null)[]
-    | void,
+    string | string[] | number | null | (number | null)[] | void,
   ...
 };
 

package/flow/dom.js.flow

@@ -172,68 +172,52 @@ type EventHandler = (event: Event) => unknown;
 type EventListener = {handleEvent: EventHandler, ...} | EventHandler;
 type MouseEventHandler = (event: MouseEvent) => unknown;
 type MouseEventListener =
-  | {handleEvent: MouseEventHandler, ...}
-  | MouseEventHandler;
+  {handleEvent: MouseEventHandler, ...} | MouseEventHandler;
 type FocusEventHandler = (event: FocusEvent) => unknown;
 type FocusEventListener =
-  | {handleEvent: FocusEventHandler, ...}
-  | FocusEventHandler;
+  {handleEvent: FocusEventHandler, ...} | FocusEventHandler;
 type KeyboardEventHandler = (event: KeyboardEvent) => unknown;
 type KeyboardEventListener =
-  | {handleEvent: KeyboardEventHandler, ...}
-  | KeyboardEventHandler;
+  {handleEvent: KeyboardEventHandler, ...} | KeyboardEventHandler;
 type InputEventHandler = (event: InputEvent) => unknown;
 type InputEventListener =
-  | {handleEvent: InputEventHandler, ...}
-  | InputEventHandler;
+  {handleEvent: InputEventHandler, ...} | InputEventHandler;
 type TouchEventHandler = (event: TouchEvent) => unknown;
 type TouchEventListener =
-  | {handleEvent: TouchEventHandler, ...}
-  | TouchEventHandler;
+  {handleEvent: TouchEventHandler, ...} | TouchEventHandler;
 type WheelEventHandler = (event: WheelEvent) => unknown;
 type WheelEventListener =
-  | {handleEvent: WheelEventHandler, ...}
-  | WheelEventHandler;
+  {handleEvent: WheelEventHandler, ...} | WheelEventHandler;
 type AbortProgressEventHandler = (event: ProgressEvent) => unknown;
 type AbortProgressEventListener =
-  | {handleEvent: AbortProgressEventHandler, ...}
-  | AbortProgressEventHandler;
+  {handleEvent: AbortProgressEventHandler, ...} | AbortProgressEventHandler;
 type ProgressEventHandler = (event: ProgressEvent) => unknown;
 type ProgressEventListener =
-  | {handleEvent: ProgressEventHandler, ...}
-  | ProgressEventHandler;
+  {handleEvent: ProgressEventHandler, ...} | ProgressEventHandler;
 type DragEventHandler = (event: DragEvent) => unknown;
 type DragEventListener =
-  | {handleEvent: DragEventHandler, ...}
-  | DragEventHandler;
+  {handleEvent: DragEventHandler, ...} | DragEventHandler;
 type PointerEventHandler = (event: PointerEvent) => unknown;
 type PointerEventListener =
-  | {handleEvent: PointerEventHandler, ...}
-  | PointerEventHandler;
+  {handleEvent: PointerEventHandler, ...} | PointerEventHandler;
 type AnimationEventHandler = (event: AnimationEvent) => unknown;
 type AnimationEventListener =
-  | {handleEvent: AnimationEventHandler, ...}
-  | AnimationEventHandler;
+  {handleEvent: AnimationEventHandler, ...} | AnimationEventHandler;
 type ClipboardEventHandler = (event: ClipboardEvent) => unknown;
 type ClipboardEventListener =
-  | {handleEvent: ClipboardEventHandler, ...}
-  | ClipboardEventHandler;
+  {handleEvent: ClipboardEventHandler, ...} | ClipboardEventHandler;
 type TransitionEventHandler = (event: TransitionEvent) => unknown;
 type TransitionEventListener =
-  | {handleEvent: TransitionEventHandler, ...}
-  | TransitionEventHandler;
+  {handleEvent: TransitionEventHandler, ...} | TransitionEventHandler;
 type MessageEventHandler = (event: MessageEvent) => unknown;
 type MessageEventListener =
-  | {handleEvent: MessageEventHandler, ...}
-  | MessageEventHandler;
+  {handleEvent: MessageEventHandler, ...} | MessageEventHandler;
 type BeforeUnloadEventHandler = (event: BeforeUnloadEvent) => unknown;
 type BeforeUnloadEventListener =
-  | {handleEvent: BeforeUnloadEventHandler, ...}
-  | BeforeUnloadEventHandler;
+  {handleEvent: BeforeUnloadEventHandler, ...} | BeforeUnloadEventHandler;
 type StorageEventHandler = (event: StorageEvent) => unknown;
 type StorageEventListener =
-  | {handleEvent: StorageEventHandler, ...}
-  | StorageEventHandler;
+  {handleEvent: StorageEventHandler, ...} | StorageEventHandler;
 type SecurityPolicyViolationEventHandler = (
   event: SecurityPolicyViolationEvent,
 ) => unknown;
@@ -242,8 +226,7 @@ type SecurityPolicyViolationEventListener =
   | SecurityPolicyViolationEventHandler;
 type USBConnectionEventHandler = (event: USBConnectionEvent) => unknown;
 type USBConnectionEventListener =
-  | {handleEvent: USBConnectionEventHandler, ...}
-  | USBConnectionEventHandler;
+  {handleEvent: USBConnectionEventHandler, ...} | USBConnectionEventHandler;
 
 type MediaKeySessionType = 'temporary' | 'persistent-license';
 type MediaKeyStatus =
@@ -272,13 +255,7 @@ type TouchEventTypes = 'touchstart' | 'touchmove' | 'touchend' | 'touchcancel';
 type WheelEventTypes = 'wheel';
 type AbortProgressEventTypes = 'abort';
 type ProgressEventTypes =
-  | 'abort'
-  | 'error'
-  | 'load'
-  | 'loadend'
-  | 'loadstart'
-  | 'progress'
-  | 'timeout';
+  'abort' | 'error' | 'load' | 'loadend' | 'loadstart' | 'progress' | 'timeout';
 type DragEventTypes =
   | 'drag'
   | 'dragend'
@@ -300,15 +277,10 @@ type PointerEventTypes =
   | 'gotpointercapture'
   | 'lostpointercapture';
 type AnimationEventTypes =
-  | 'animationstart'
-  | 'animationend'
-  | 'animationiteration';
+  'animationstart' | 'animationend' | 'animationiteration';
 type ClipboardEventTypes = 'clipboardchange' | 'cut' | 'copy' | 'paste';
 type TransitionEventTypes =
-  | 'transitionrun'
-  | 'transitionstart'
-  | 'transitionend'
-  | 'transitioncancel';
+  'transitionrun' | 'transitionstart' | 'transitionend' | 'transitioncancel';
 type MessageEventTypes = string;
 type BeforeUnloadEventTypes = 'beforeunload';
 type StorageEventTypes = 'storage';
@@ -6051,8 +6023,7 @@ type NodeFilterCallback = (
   | typeof NodeFilter.FILTER_SKIP;
 
 type NodeFilterInterface =
-  | NodeFilterCallback
-  | {acceptNode: NodeFilterCallback, ...};
+  NodeFilterCallback | {acceptNode: NodeFilterCallback, ...};
 
 // TODO: window.NodeFilter exists at runtime and behaves as a constructor
 //       as far as `instanceof` is concerned, but it is not callable.

package/flow/global.js

@@ -18,70 +18,70 @@
 // $FlowFixMe[libdef-override]
 declare var global: {
   // setUpGlobals
-  +window: typeof global,
-  +self: typeof global,
-  +process: {
-    +env: {
-      +NODE_ENV: 'development' | 'production',
+  readonly window: typeof global,
+  readonly self: typeof global,
+  readonly process: {
+    readonly env: {
+      readonly NODE_ENV: 'development' | 'production',
     },
-    +argv?: ReadonlyArray<string>,
+    readonly argv?: ReadonlyArray<string>,
   },
 
   // setUpPerformance
-  +performance: Performance,
+  readonly performance: Performance,
 
   // setUpXHR
-  +XMLHttpRequest: typeof XMLHttpRequest,
-  +FormData: typeof FormData,
-  +fetch: typeof fetch,
-  +Headers: typeof Headers,
-  +Request: typeof Request,
-  +Response: typeof Response,
-  +WebSocket: typeof WebSocket,
-  +Blob: typeof Blob,
-  +File: typeof File,
-  +FileReader: typeof FileReader,
-  +URL: typeof URL,
-  +URLSearchParams: typeof URLSearchParams,
-  +AbortController: typeof AbortController,
-  +AbortSignal: typeof AbortSignal,
+  readonly XMLHttpRequest: typeof XMLHttpRequest,
+  readonly FormData: typeof FormData,
+  readonly fetch: typeof fetch,
+  readonly Headers: typeof Headers,
+  readonly Request: typeof Request,
+  readonly Response: typeof Response,
+  readonly WebSocket: typeof WebSocket,
+  readonly Blob: typeof Blob,
+  readonly File: typeof File,
+  readonly FileReader: typeof FileReader,
+  readonly URL: typeof URL,
+  readonly URLSearchParams: typeof URLSearchParams,
+  readonly AbortController: typeof AbortController,
+  readonly AbortSignal: typeof AbortSignal,
 
   // setUpAlert
-  +alert: typeof alert,
+  readonly alert: typeof alert,
 
   // setUpNavigator
-  +navigator: {
-    +product: 'ReactNative',
-    +appName?: ?string,
+  readonly navigator: {
+    readonly product: 'ReactNative',
+    readonly appName?: ?string,
     ...
   },
 
   // setUpTimers
-  +setInterval: typeof setInterval,
-  +clearInterval: typeof clearInterval,
-  +setTimeout: typeof setTimeout,
-  +clearTimeout: typeof clearTimeout,
-  +requestAnimationFrame: typeof requestAnimationFrame,
-  +cancelAnimationFrame: typeof cancelAnimationFrame,
-  +requestIdleCallback: typeof requestIdleCallback,
-  +cancelIdleCallback: typeof cancelIdleCallback,
-  +queueMicrotask: typeof queueMicrotask,
-  +setImmediate: typeof setImmediate,
-  +clearImmediate: typeof clearImmediate,
+  readonly setInterval: typeof setInterval,
+  readonly clearInterval: typeof clearInterval,
+  readonly setTimeout: typeof setTimeout,
+  readonly clearTimeout: typeof clearTimeout,
+  readonly requestAnimationFrame: typeof requestAnimationFrame,
+  readonly cancelAnimationFrame: typeof cancelAnimationFrame,
+  readonly requestIdleCallback: typeof requestIdleCallback,
+  readonly cancelIdleCallback: typeof cancelIdleCallback,
+  readonly queueMicrotask: typeof queueMicrotask,
+  readonly setImmediate: typeof setImmediate,
+  readonly clearImmediate: typeof clearImmediate,
 
   // Polyfills
-  +console: typeof console,
+  readonly console: typeof console,
 
   // JavaScript environments specific
-  +HermesInternal: ?$HermesInternalType,
+  readonly HermesInternal: ?$HermesInternalType,
 
   // Internal-specific
-  +__DEV__?: boolean,
-  +RN$Bridgeless?: boolean,
+  readonly __DEV__?: boolean,
+  readonly RN$Bridgeless?: boolean,
 
   // setupDOM
-  +DOMRect: typeof DOMRect,
-  +DOMRectReadOnly: typeof DOMRectReadOnly,
+  readonly DOMRect: typeof DOMRect,
+  readonly DOMRectReadOnly: typeof DOMRectReadOnly,
 
   // Undeclared properties are implicitly `any`.
   [string | symbol]: any,