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

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

@@ -0,0 +1,70 @@
+/**
+ * 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 {setPlatformObject} from '../webidl/PlatformObjects';
+
+/**
+ * The [`ResizeObserverSize`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverSize)
+ * interface of the Resize Observer API is used to store the block and inline
+ * sizes of a box as separate properties.
+ *
+ * It is returned by the `borderBoxSize`, `contentBoxSize` and
+ * `devicePixelContentBoxSize` properties of `ResizeObserverEntry`.
+ */
+export default class ResizeObserverSize {
+  _inlineSize: number;
+  _blockSize: number;
+
+  constructor(inlineSize: number, blockSize: number) {
+    this._inlineSize = inlineSize;
+    this._blockSize = blockSize;
+  }
+
+  /**
+   * The length of the observed box in the inline dimension. For boxes with a
+   * horizontal writing-mode, this is the horizontal dimension, or width; if
+   * the writing-mode is vertical, this is the vertical dimension, or height.
+   *
+   * React Native assumes a horizontal writing-mode, so this is the width.
+   */
+  get inlineSize(): number {
+    return this._inlineSize;
+  }
+
+  /**
+   * The length of the observed box in the block dimension. For boxes with a
+   * horizontal writing-mode, this is the vertical dimension, or height; if the
+   * writing-mode is vertical, this is the horizontal dimension, or width.
+   *
+   * React Native assumes a horizontal writing-mode, so this is the height.
+   */
+  get blockSize(): number {
+    return this._blockSize;
+  }
+}
+
+setPlatformObject(ResizeObserverSize);
+
+// `ResizeObserverSize` is not constructible from user code on the Web (its IDL
+// declares no constructor). We expose this wrapper as the global instead of the
+// class above, which we still use internally to build entries.
+export const ResizeObserverSize_public: typeof ResizeObserverSize =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function ResizeObserverSize() {
+    throw new TypeError(
+      "Failed to construct 'ResizeObserverSize': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+ResizeObserverSize_public.prototype = ResizeObserverSize.prototype;

package/src/private/webapis/resizeobserver/internals/ResizeObserverManager.js

@@ -0,0 +1,276 @@
+/**
+ * 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
+ */
+
+/**
+ * This module handles the communication between the React Native renderer
+ * and all the resize observers that are currently observing any targets.
+ *
+ * In order to reduce the communication between native and JavaScript,
+ * we register a single notification callback in native, and then we handle
+ * how to notify each entry to the right resize observer when we receive all
+ * the notifications together.
+ */
+
+import type ReactNativeElement from '../../dom/nodes/ReactNativeElement';
+import type ResizeObserver, {
+  ResizeObserverBoxOptions,
+  ResizeObserverCallback,
+} from '../ResizeObserver';
+import type ResizeObserverEntry from '../ResizeObserverEntry';
+import type {NativeResizeObserverToken} from '../specs/NativeResizeObserver';
+
+import {trace} from '../../../../../Libraries/Performance/Systrace';
+import {
+  getInstanceHandle,
+  getNativeNodeReference,
+} from '../../dom/nodes/internals/NodeInternals';
+import {createResizeObserverEntry} from '../ResizeObserverEntry';
+import NativeResizeObserver from '../specs/NativeResizeObserver';
+
+export type ResizeObserverId = number;
+
+let nextResizeObserverId: ResizeObserverId = 1;
+let isConnected: boolean = false;
+
+const registeredResizeObservers: Map<
+  ResizeObserverId,
+  {observer: ResizeObserver, callback: ResizeObserverCallback},
+> = new Map();
+
+// Keep our own instanceHandle->target map: when a target unmounts, React
+// resets its instance handle (to avoid leaks), cutting the built-in link.
+const instanceHandleToTargetMap: WeakMap<interface {}, ReactNativeElement> =
+  new WeakMap();
+
+function getTargetFromInstanceHandle(
+  instanceHandle: unknown,
+): ?ReactNativeElement {
+  // $FlowExpectedError[incompatible-type] instanceHandle is typed as mixed but we know it's an object and we need it to be to use it as a key in a WeakMap.
+  const key: interface {} = instanceHandle;
+  return instanceHandleToTargetMap.get(key);
+}
+
+function setTargetForInstanceHandle(
+  instanceHandle: unknown,
+  target: ReactNativeElement,
+): void {
+  // $FlowExpectedError[incompatible-type] instanceHandle is typed as mixed but we know it's an object and we need it to be to use it as a key in a WeakMap.
+  const key: interface {} = instanceHandle;
+  instanceHandleToTargetMap.set(key, target);
+}
+
+// Keep the native token per target: on unmount a target loses its shadow node
+// reference, and without the token we couldn't clean up the observation.
+const targetToTokenMap: WeakMap<ReactNativeElement, NativeResizeObserverToken> =
+  new WeakMap();
+
+/**
+ * Registers the given resize observer and returns a unique ID for it, which
+ * is required to start observing targets.
+ */
+export function registerObserver(
+  observer: ResizeObserver,
+  callback: ResizeObserverCallback,
+): ResizeObserverId {
+  const resizeObserverId = nextResizeObserverId;
+  nextResizeObserverId++;
+  registeredResizeObservers.set(resizeObserverId, {
+    observer,
+    callback,
+  });
+  return resizeObserverId;
+}
+
+/**
+ * Unregisters the given resize observer.
+ * This should only be called when an observer is no longer observing any
+ * targets.
+ */
+export function unregisterObserver(resizeObserverId: ResizeObserverId): void {
+  const deleted = registeredResizeObservers.delete(resizeObserverId);
+  if (deleted && registeredResizeObservers.size === 0) {
+    NativeResizeObserver?.disconnect();
+    isConnected = false;
+  }
+}
+
+/**
+ * Starts observing a target on a specific resize observer.
+ * If this is the first target being observed, this also sets up the
+ * centralized notification callback in native.
+ * Returns `true` if the native observation was actually set up, or `false`
+ * if the target could not be observed (e.g. because it is disconnected).
+ */
+export function observe({
+  resizeObserverId,
+  target,
+  box,
+}: {
+  resizeObserverId: ResizeObserverId,
+  target: ReactNativeElement,
+  box: ResizeObserverBoxOptions,
+}): boolean {
+  if (NativeResizeObserver == null) {
+    throwIfNoNativeResizeObserver();
+    return false;
+  }
+
+  const registeredObserver = registeredResizeObservers.get(resizeObserverId);
+  if (registeredObserver == null) {
+    console.error(
+      `ResizeObserverManager: could not start observing target because ResizeObserver with ID ${resizeObserverId} was not registered.`,
+    );
+    return false;
+  }
+
+  const targetNativeNodeReference = getNativeNodeReference(target);
+  if (targetNativeNodeReference == null) {
+    // The target is disconnected. We can't observe it anymore.
+    return false;
+  }
+
+  const instanceHandle = getInstanceHandle(target);
+  if (instanceHandle == null) {
+    console.error(
+      'ResizeObserverManager: could not find reference to instance handle from target',
+    );
+    return false;
+  }
+
+  // Store the mapping between the instance handle and the target so we can
+  // access it even after the instance handle has been unmounted.
+  setTargetForInstanceHandle(instanceHandle, target);
+
+  if (!isConnected) {
+    NativeResizeObserver.connect(notifyResizeObservers);
+    isConnected = true;
+  }
+
+  const token = NativeResizeObserver.observe({
+    resizeObserverId,
+    targetShadowNode: targetNativeNodeReference,
+    box,
+  });
+  targetToTokenMap.set(target, token);
+
+  return true;
+}
+
+/**
+ * Instructs the given resize observer to stop observing the specified
+ * target.
+ */
+export function unobserve(
+  resizeObserverId: ResizeObserverId,
+  target: ReactNativeElement,
+): void {
+  if (NativeResizeObserver == null) {
+    throwIfNoNativeResizeObserver();
+    return;
+  }
+
+  const registeredObserver = registeredResizeObservers.get(resizeObserverId);
+  if (registeredObserver == null) {
+    console.error(
+      `ResizeObserverManager: could not stop observing target because ResizeObserver with ID ${resizeObserverId} was not registered.`,
+    );
+    return;
+  }
+
+  const targetToken = targetToTokenMap.get(target);
+  if (targetToken == null) {
+    console.error(
+      'ResizeObserverManager: could not find registration data for target',
+    );
+    return;
+  }
+
+  NativeResizeObserver.unobserve(resizeObserverId, targetToken);
+}
+
+/**
+ * This function is called from native when there are `ResizeObserver`
+ * entries to dispatch.
+ */
+function notifyResizeObservers(hasResizeLoopError: boolean): void {
+  trace('ResizeObserverManager.notifyResizeObservers', () => {
+    doNotifyResizeObservers(hasResizeLoopError);
+  });
+}
+
+function doNotifyResizeObservers(hasResizeLoopError: boolean): void {
+  if (NativeResizeObserver == null) {
+    throwIfNoNativeResizeObserver();
+    return;
+  }
+
+  const nativeEntries = NativeResizeObserver.takeRecords();
+
+  const entriesByObserver: Map<
+    ResizeObserverId,
+    Array<ResizeObserverEntry>,
+  > = new Map();
+
+  for (const nativeEntry of nativeEntries) {
+    let list = entriesByObserver.get(nativeEntry.resizeObserverId);
+    if (list == null) {
+      list = [];
+      entriesByObserver.set(nativeEntry.resizeObserverId, list);
+    }
+
+    const target = getTargetFromInstanceHandle(
+      nativeEntry.targetInstanceHandle,
+    );
+    if (target == null) {
+      console.warn(
+        'ResizeObserverManager: could not find target to create ResizeObserverEntry',
+      );
+      continue;
+    }
+
+    list.push(createResizeObserverEntry(nativeEntry, target));
+  }
+
+  // Native delivers entries in observer registration order; preserve it (Map
+  // insertion order isn't enough if batches merged out of order).
+  const observerIds = Array.from(entriesByObserver.keys()).sort(
+    (a, b) => a - b,
+  );
+  for (const resizeObserverId of observerIds) {
+    const entriesForObserver = entriesByObserver.get(resizeObserverId);
+    if (entriesForObserver == null) {
+      continue;
+    }
+
+    const registeredObserver = registeredResizeObservers.get(resizeObserverId);
+    if (!registeredObserver) {
+      // This could happen if the observer is disconnected between commit
+      // and mount. In this case, we can just ignore the entries.
+      continue;
+    }
+
+    const {observer, callback} = registeredObserver;
+    try {
+      callback.call(observer, entriesForObserver, observer);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  if (hasResizeLoopError) {
+    console.error(
+      'ResizeObserver loop completed with undelivered notifications.',
+    );
+  }
+}
+
+function throwIfNoNativeResizeObserver() {
+  throw new Error('Missing native implementation of ResizeObserver');
+}

package/src/private/webapis/resizeobserver/specs/NativeResizeObserver.js

@@ -0,0 +1,50 @@
+/**
+ * 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
+ * @format
+ */
+
+import type {TurboModule} from '../../../../../Libraries/TurboModule/RCTExport';
+
+import * as TurboModuleRegistry from '../../../../../Libraries/TurboModule/TurboModuleRegistry';
+
+export type NativeResizeObserverEntry = {
+  resizeObserverId: number,
+  targetInstanceHandle: unknown,
+  contentRect: ReadonlyArray<number>, // It's actually a tuple with x, y, width and height
+  borderBoxSize: ReadonlyArray<number>, // It's actually a tuple with inlineSize and blockSize
+  contentBoxSize: ReadonlyArray<number>, // It's actually a tuple with inlineSize and blockSize
+  devicePixelContentBoxSize: ReadonlyArray<number>, // It's actually a tuple with inlineSize and blockSize
+};
+
+export type NativeResizeObserverObserveOptions = {
+  resizeObserverId: number,
+  targetShadowNode: unknown,
+  // Corresponds to the `box` option of `ResizeObserver#observe`.
+  box?: ?string,
+};
+
+export opaque type NativeResizeObserverToken = unknown;
+
+export interface Spec extends TurboModule {
+  readonly observe: (
+    options: NativeResizeObserverObserveOptions,
+  ) => NativeResizeObserverToken;
+  readonly unobserve: (
+    resizeObserverId: number,
+    targetToken: NativeResizeObserverToken,
+  ) => void;
+  readonly connect: (
+    notifyResizeObserversFunction: (hasResizeLoopError: boolean) => void,
+  ) => void;
+  readonly disconnect: () => void;
+  readonly takeRecords: () => ReadonlyArray<NativeResizeObserverEntry>;
+}
+
+export default TurboModuleRegistry.get<Spec>(
+  'NativeResizeObserverCxx',
+) as ?Spec;

package/src/react-private-interface.js

@@ -29,6 +29,7 @@ import typeof ExceptionsManager from '../Libraries/Core/ExceptionsManager';
 import typeof RawEventEmitter from '../Libraries/Core/RawEventEmitter';
 import typeof ReactFiberErrorDialog from '../Libraries/Core/ReactFiberErrorDialog';
 import typeof RCTEventEmitter from '../Libraries/EventEmitter/RCTEventEmitter';
+import type {Spec as FabricUIManager} from '../Libraries/ReactNative/FabricUIManager';
 import typeof {
   createPublicInstance,
   createPublicRootInstance,
@@ -48,6 +49,7 @@ import type {DangerouslyImpreciseStyleProp} from '../Libraries/StyleSheet/StyleS
 import typeof deepFreezeAndThrowOnMutationInDev from '../Libraries/Utilities/deepFreezeAndThrowOnMutationInDev';
 import typeof deepDiffer from '../Libraries/Utilities/differ/deepDiffer';
 import typeof Platform from '../Libraries/Utilities/Platform';
+import typeof * as ReactNativeFeatureFlags from './private/featureflags/ReactNativeFeatureFlags';
 import typeof dispatchNativeEvent from './private/renderer/events/dispatchNativeEvent';
 import typeof CustomEvent from './private/webapis/dom/events/CustomEvent';
 
@@ -69,6 +71,9 @@ module.exports = {
   get RCTEventEmitter(): RCTEventEmitter {
     return require('../Libraries/EventEmitter/RCTEventEmitter').default;
   },
+  get ReactNativeFeatureFlags(): ReactNativeFeatureFlags {
+    return require('./private/featureflags/ReactNativeFeatureFlags');
+  },
   get ReactNativeViewConfigRegistry(): ReactNativeViewConfigRegistry {
     return require('../Libraries/Renderer/shims/ReactNativeViewConfigRegistry');
   },
@@ -78,6 +83,9 @@ module.exports = {
   get UIManager(): UIManager {
     return require('../Libraries/ReactNative/UIManager').default;
   },
+  get fabricUIManager(): ?FabricUIManager {
+    return require('../Libraries/ReactNative/FabricUIManager').getFabricUIManager();
+  },
   // TODO: Remove when React has migrated to `createAttributePayload` and `diffAttributePayloads`
   get deepDiffer(): deepDiffer {
     return require('../Libraries/Utilities/differ/deepDiffer').default;

package/src/react-private-interface.js.flow

@@ -14,6 +14,7 @@
 // IMPORTANT: Keep this file in sync with react-private-interface.js.
 // ----------------------------------------------------------------------------
 
+import type {Spec as FabricUIManager} from '../Libraries/ReactNative/FabricUIManager';
 import typeof {createPublicTextInstance as createPublicTextInstanceT} from '../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance';
 
 export type {PublicRootInstance} from '../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance';
@@ -23,9 +24,11 @@ export {default as BatchedBridge} from '../Libraries/BatchedBridge/BatchedBridge
 export {default as ExceptionsManager} from '../Libraries/Core/ExceptionsManager';
 export {default as Platform} from '../Libraries/Utilities/Platform';
 export {default as RCTEventEmitter} from '../Libraries/EventEmitter/RCTEventEmitter';
+export * as ReactNativeFeatureFlags from './private/featureflags/ReactNativeFeatureFlags';
 export * as ReactNativeViewConfigRegistry from '../Libraries/Renderer/shims/ReactNativeViewConfigRegistry';
 export {default as TextInputState} from '../Libraries/Components/TextInput/TextInputState';
 export {default as UIManager} from '../Libraries/ReactNative/UIManager';
+declare export const fabricUIManager: ?FabricUIManager;
 export {default as deepDiffer} from '../Libraries/Utilities/differ/deepDiffer';
 export {default as deepFreezeAndThrowOnMutationInDev} from '../Libraries/Utilities/deepFreezeAndThrowOnMutationInDev';
 export {default as flattenStyle} from '../Libraries/StyleSheet/flattenStyle';

package/src/types/ErrorUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ *
+ * @format
+ */
+
+// From @react-native/js-polyfills
+
+type ErrorHandlerCallback = (error: any, isFatal?: boolean) => void;
+
+export interface ErrorUtils {
+  setGlobalHandler: (callback: ErrorHandlerCallback) => void;
+  getGlobalHandler: () => ErrorHandlerCallback;
+}

package/src/types/globals.d.ts

@@ -7,7 +7,7 @@
  * @format
  */
 
-import type {ErrorUtils} from '../../Libraries/vendor/core/ErrorUtils';
+import type {ErrorUtils} from './ErrorUtils';
 
 declare global {
   interface NodeRequire {
@@ -125,6 +125,15 @@ declare global {
   function cancelAnimationFrame(handle: number | null | undefined): void;
   function requestAnimationFrame(callback: (time: number) => void): number;
 
+  function requestIdleCallback(
+    callback: (deadline: {
+      didTimeout: boolean;
+      timeRemaining: () => number;
+    }) => void,
+    options?: {timeout?: number | undefined},
+  ): number;
+  function cancelIdleCallback(handle: number | null | undefined): void;
+
   function fetchBundle(
     bundleId: number,
     callback: (error?: Error | null) => void,
@@ -322,12 +331,7 @@ declare global {
   type RequestCredentials_ = 'omit' | 'same-origin' | 'include';
   type RequestMode_ = 'navigate' | 'same-origin' | 'no-cors' | 'cors';
   type ResponseType_ =
-    | 'basic'
-    | 'cors'
-    | 'default'
-    | 'error'
-    | 'opaque'
-    | 'opaqueredirect';
+    'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
 
   // #endregion
   // #region XMLHttpRequest
@@ -429,8 +433,7 @@ declare global {
   }
 
   interface XMLHttpRequestUpload
-    extends EventTarget,
-      XMLHttpRequestEventTarget {
+    extends EventTarget, XMLHttpRequestEventTarget {
     addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(
       type: K,
       listener: (
@@ -453,12 +456,7 @@ declare global {
   };
 
   type XMLHttpRequestResponseType =
-    | ''
-    | 'arraybuffer'
-    | 'blob'
-    | 'document'
-    | 'json'
-    | 'text';
+    '' | 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
 
   interface URL {
     readonly hash: string;
@@ -690,14 +688,11 @@ declare global {
     onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
     onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
     onloadend:
-      | ((this: FileReader, ev: ProgressEvent<FileReader>) => any)
-      | null;
+      ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
     onloadstart:
-      | ((this: FileReader, ev: ProgressEvent<FileReader>) => any)
-      | null;
+      ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
     onprogress:
-      | ((this: FileReader, ev: ProgressEvent<FileReader>) => any)
-      | null;
+      ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
     readonly readyState: number;
     readonly result: string | ArrayBuffer;
     abort(): void;

package/third-party-podspecs/replace_dependencies_version.js

@@ -10,8 +10,8 @@
 
 'use strict';
 
-const {spawnSync} = require('child_process');
-const fs = require('fs');
+const {spawnSync} = require('node:child_process');
+const fs = require('node:fs');
 const yargs = require('yargs');
 
 const LAST_BUILD_FILENAME = 'ReactNativeDependencies/.last_build_configuration';

package/{Libraries → types_DEPRECATED/Libraries}/Alert/Alert.d.ts

@@ -85,10 +85,7 @@ export interface AlertStatic {
 }
 
 export type AlertType =
-  | 'default'
-  | 'plain-text'
-  | 'secure-text'
-  | 'login-password';
+  'default' | 'plain-text' | 'secure-text' | 'login-password';
 
 export const Alert: AlertStatic;
 export type Alert = AlertStatic;

package/{Libraries → types_DEPRECATED/Libraries}/Animated/Animated.d.ts

@@ -78,11 +78,7 @@ export namespace Animated {
   };
 
   type AnimatedColorInputValue =
-    | RgbaValue
-    | RgbaAnimatedValue
-    | ColorValue
-    | null
-    | undefined;
+    RgbaValue | RgbaAnimatedValue | ColorValue | null | undefined;
 
   class AnimatedColor extends AnimatedWithChildren {
     r: AnimatedValue;
@@ -542,8 +538,7 @@ export namespace Animated {
   ): (...args: any[]) => void;
 
   export type ComponentProps<T> = T extends
-    | React.ComponentType<infer P>
-    | React.Component<infer P>
+    React.ComponentType<infer P> | React.Component<infer P>
     ? P
     : never;
 
@@ -586,8 +581,9 @@ export namespace Animated {
       : WithAnimatedValue<T[key]>;
   };
 
-  export interface AnimatedComponent<T extends React.ComponentType<any>>
-    extends React.FC<AnimatedProps<React.ComponentPropsWithRef<T>>> {}
+  export interface AnimatedComponent<
+    T extends React.ComponentType<any>,
+  > extends React.FC<AnimatedProps<React.ComponentPropsWithRef<T>>> {}
 
   export type AnimatedComponentOptions = {
     collapsable?: boolean | undefined;

package/{Libraries → types_DEPRECATED/Libraries}/AppState/AppState.d.ts

@@ -37,11 +37,7 @@ import {NativeEventSubscription} from '../EventEmitter/RCTNativeAppEventEmitter'
  */
 export type AppStateEvent = 'change' | 'memoryWarning' | 'blur' | 'focus';
 export type AppStateStatus =
-  | 'active'
-  | 'background'
-  | 'inactive'
-  | 'unknown'
-  | 'extension';
+  'active' | 'background' | 'inactive' | 'unknown' | 'extension';
 
 export interface AppStateStatic {
   currentState: AppStateStatus;

package/{Libraries → types_DEPRECATED/Libraries}/Components/AccessibilityInfo/AccessibilityInfo.d.ts

@@ -7,7 +7,7 @@
  * @format
  */
 
-import {HostInstance} from '../../../types/public/ReactNativeTypes';
+import {HostInstance} from '../../../public/ReactNativeTypes';
 import {EmitterSubscription} from '../../vendor/emitter/EventEmitter';
 
 type AccessibilityChangeEventName =
@@ -46,10 +46,7 @@ type AccessibilityAnnouncementFinishedEventHandler = (
 ) => void;
 
 type AccessibilityEventTypes =
-  | 'click'
-  | 'focus'
-  | 'viewHoverEnter'
-  | 'windowStateChange';
+  'click' | 'focus' | 'viewHoverEnter' | 'windowStateChange';
 
 /**
  * @see https://reactnative.dev/docs/accessibilityinfo

package/{Libraries → types_DEPRECATED/Libraries}/Components/ActivityIndicator/ActivityIndicator.d.ts

@@ -8,8 +8,8 @@
  */
 
 import type * as React from 'react';
-import {Constructor} from '../../../types/private/Utilities';
-import {HostInstance} from '../../../types/public/ReactNativeTypes';
+import {Constructor} from '../../../private/Utilities';
+import {HostInstance} from '../../../public/ReactNativeTypes';
 import {ColorValue, StyleProp} from '../../StyleSheet/StyleSheet';
 import {ViewStyle} from '../../StyleSheet/StyleSheetTypes';
 import {LayoutChangeEvent} from '../../Types/CoreEventTypes';