react-native-tvos 0.79.2-0 → 0.80.0-0

package/Libraries/Animated/components/AnimatedScrollView.js

@@ -23,48 +23,51 @@ import useAnimatedProps from '../useAnimatedProps';
 import * as React from 'react';
 import {useMemo} from 'react';
 
-type Props = React.ElementConfig<typeof ScrollView>;
-type Instance = React.ElementRef<typeof ScrollView>;
+type AnimatedScrollViewProps = React.ElementConfig<typeof ScrollView>;
+type AnimatedScrollViewInstance = React.ElementRef<typeof ScrollView>;
 
 /**
  * @see https://github.com/facebook/react-native/commit/b8c8562
  */
-const AnimatedScrollView: AnimatedComponentType<Props, Instance> =
-  React.forwardRef(
-    function AnimatedScrollViewWithOrWithoutInvertedRefreshControl(
-      props,
-      forwardedRef,
+const AnimatedScrollView: AnimatedComponentType<
+  AnimatedScrollViewProps,
+  AnimatedScrollViewInstance,
+> = React.forwardRef(
+  function AnimatedScrollViewWithOrWithoutInvertedRefreshControl(
+    props,
+    forwardedRef,
+  ) {
+    // (Android only) When a ScrollView has a RefreshControl and
+    // any `style` property set with an Animated.Value, the CSS
+    // gets incorrectly applied twice. This is because ScrollView
+    // swaps the parent/child relationship of itself and the
+    // RefreshControl component (see ScrollView.js for more details).
+    if (
+      Platform.OS === 'android' &&
+      props.refreshControl != null &&
+      props.style != null
     ) {
-      // (Android only) When a ScrollView has a RefreshControl and
-      // any `style` property set with an Animated.Value, the CSS
-      // gets incorrectly applied twice. This is because ScrollView
-      // swaps the parent/child relationship of itself and the
-      // RefreshControl component (see ScrollView.js for more details).
-      if (
-        Platform.OS === 'android' &&
-        props.refreshControl != null &&
-        props.style != null
-      ) {
-        return (
-          // $FlowFixMe[prop-missing]
-          <AnimatedScrollViewWithInvertedRefreshControl
-            scrollEventThrottle={0.0001}
-            {...props}
-            ref={forwardedRef}
-            refreshControl={props.refreshControl}
-          />
-        );
-      } else {
-        return (
-          <AnimatedScrollViewWithoutInvertedRefreshControl
-            scrollEventThrottle={0.0001}
-            {...props}
-            ref={forwardedRef}
-          />
-        );
-      }
-    },
-  );
+      return (
+        // $FlowFixMe - It should return an Animated ScrollView but it returns a ScrollView with Animated props applied.
+        <AnimatedScrollViewWithInvertedRefreshControl
+          scrollEventThrottle={0.0001}
+          {...props}
+          ref={forwardedRef}
+          // $FlowFixMe[incompatible-type]
+          refreshControl={props.refreshControl}
+        />
+      );
+    } else {
+      return (
+        <AnimatedScrollViewWithoutInvertedRefreshControl
+          scrollEventThrottle={0.0001}
+          {...props}
+          ref={forwardedRef}
+        />
+      );
+    }
+  },
+);
 
 const AnimatedScrollViewWithInvertedRefreshControl = React.forwardRef(
   // $FlowFixMe[incompatible-call]
@@ -75,8 +78,8 @@ const AnimatedScrollViewWithInvertedRefreshControl = React.forwardRef(
       refreshControl: ExactReactElement_DEPRECATED<any>,
     },
     forwardedRef:
-      | {current: Instance | null, ...}
-      | ((Instance | null) => mixed),
+      | {current: AnimatedScrollViewInstance | null, ...}
+      | ((AnimatedScrollViewInstance | null) => mixed),
   ) {
     // Split `props` into the animate-able props for the parent (RefreshControl)
     // and child (ScrollView).
@@ -106,10 +109,13 @@ const AnimatedScrollViewWithInvertedRefreshControl = React.forwardRef(
 
     // Handle animated props on `NativeDirectionalScrollView`.
     const [scrollViewAnimatedProps, scrollViewRef] = useAnimatedProps<
-      Props,
-      Instance,
+      AnimatedScrollViewProps,
+      AnimatedScrollViewInstance,
     >(intermediatePropsForScrollView);
-    const ref = useMergeRefs<Instance>(scrollViewRef, forwardedRef);
+    const ref = useMergeRefs<AnimatedScrollViewInstance>(
+      scrollViewRef,
+      forwardedRef,
+    );
 
     return (
       // $FlowFixMe[incompatible-use] Investigate useAnimatedProps return value

package/Libraries/Animated/components/AnimatedSectionList.js

@@ -8,15 +8,19 @@
  * @format
  */
 
-import type {SectionBase} from '../../Lists/SectionList';
-import type {AnimatedComponentType} from '../createAnimatedComponent';
+import type {AnimatedProps} from '../createAnimatedComponent';
 
-import SectionList from '../../Lists/SectionList';
+import SectionList, {type SectionListProps} from '../../Lists/SectionList';
 import createAnimatedComponent from '../createAnimatedComponent';
 import * as React from 'react';
 
-export default (createAnimatedComponent(SectionList): AnimatedComponentType<
-  React.ElementConfig<typeof SectionList>,
+// $FlowFixMe
+export default (createAnimatedComponent(SectionList): component<
   // $FlowExpectedError[unclear-type]
-  SectionList<SectionBase<any>>,
->);
+  ItemT = any,
+  // $FlowExpectedError[unclear-type]
+  SectionT = any,
+>(
+  ref?: React.RefSetter<SectionList<ItemT, SectionT>>,
+  ...props: AnimatedProps<SectionListProps<ItemT, SectionT>>
+));

package/Libraries/Animated/createAnimatedComponent.js

@@ -8,7 +8,16 @@
  * @format
  */
 
+import type AnimatedAddition from './nodes/AnimatedAddition';
+import type AnimatedDiffClamp from './nodes/AnimatedDiffClamp';
+import type AnimatedDivision from './nodes/AnimatedDivision';
+import type AnimatedInterpolation from './nodes/AnimatedInterpolation';
+import type AnimatedModulo from './nodes/AnimatedModulo';
+import type AnimatedMultiplication from './nodes/AnimatedMultiplication';
+import type AnimatedNode from './nodes/AnimatedNode';
 import type {AnimatedPropsAllowlist} from './nodes/AnimatedProps';
+import type AnimatedSubtraction from './nodes/AnimatedSubtraction';
+import type AnimatedValue from './nodes/AnimatedValue';
 
 import createAnimatedPropsHook from '../../src/private/animated/createAnimatedPropsHook';
 import composeStyles from '../../src/private/styles/composeStyles';
@@ -17,81 +26,120 @@ import useMergeRefs from '../Utilities/useMergeRefs';
 import * as React from 'react';
 import {useMemo} from 'react';
 
-export type AnimatedProps<Props: {...}> = {
-  // eslint-disable-next-line no-unused-vars
-  +[_K in keyof (Props &
-      $ReadOnly<{
-        passthroughAnimatedPropExplicitValues?: React.ElementConfig<
-          typeof View,
-        >,
-      }>)]: any,
-};
+type Nullable = void | null;
+type Primitive = string | number | boolean | symbol | void;
+type Builtin = (...$ReadOnlyArray<empty>) => mixed | Date | Error | RegExp;
+
+export type WithAnimatedValue<+T> = T extends Builtin | Nullable
+  ? T
+  : T extends Primitive
+    ?
+        | T
+        | AnimatedNode
+        | AnimatedAddition
+        | AnimatedSubtraction
+        | AnimatedDivision
+        | AnimatedMultiplication
+        | AnimatedModulo
+        | AnimatedDiffClamp
+        | AnimatedValue
+        | AnimatedInterpolation<number | string>
+        | AnimatedInterpolation<number>
+        | AnimatedInterpolation<string>
+    : T extends $ReadOnlyArray<infer P>
+      ? $ReadOnlyArray<WithAnimatedValue<P>>
+      : T extends {...}
+        ? {+[K in keyof T]: WithAnimatedValue<T[K]>}
+        : T;
 
-// We could use a mapped type here to introduce acceptable Animated variants
-// of properties, instead of doing so in the core StyleSheetTypes
-// Inexact Props are not supported, they'll be made exact here.
-export type StrictAnimatedProps<Props: {...}> = $ReadOnly<{
-  ...$Exact<Props>,
-  passthroughAnimatedPropExplicitValues?: ?Props,
+type NonAnimatedProps =
+  | 'ref'
+  | 'innerViewRef'
+  | 'scrollViewRef'
+  | 'testID'
+  | 'disabled'
+  | 'accessibilityLabel';
+type PassThroughProps = $ReadOnly<{
+  passthroughAnimatedPropExplicitValues?: React.ElementConfig<
+    typeof View,
+  > | null,
 }>;
 
+export type AnimatedProps<Props: {...}> = {
+  [K in keyof Props]: K extends NonAnimatedProps
+    ? Props[K]
+    : WithAnimatedValue<Props[K]>,
+} & PassThroughProps;
+
+export type AnimatedBaseProps<Props: {...}> = {
+  [K in keyof Props]: K extends NonAnimatedProps
+    ? Props[K]
+    : WithAnimatedValue<Props[K]>,
+};
+
 export type AnimatedComponentType<Props: {...}, +Instance = mixed> = component(
-  ref: React.RefSetter<Instance>,
+  ref?: React.RefSetter<Instance>,
   ...AnimatedProps<Props>
 );
 
-export type StrictAnimatedComponentType<
-  Props: {...},
-  +Instance = mixed,
-> = component(ref: React.RefSetter<Instance>, ...StrictAnimatedProps<Props>);
-
-export default function createAnimatedComponent<TProps: {...}, TInstance>(
-  Component: component(ref: React.RefSetter<TInstance>, ...TProps),
-): AnimatedComponentType<TProps, TInstance> {
+export default function createAnimatedComponent<
+  TInstance: React.ComponentType<any>,
+>(
+  Component: TInstance,
+): AnimatedComponentType<
+  $ReadOnly<React.ElementProps<TInstance>>,
+  React.ElementRef<TInstance>,
+> {
   return unstable_createAnimatedComponentWithAllowlist(Component, null);
 }
 
 export function unstable_createAnimatedComponentWithAllowlist<
   TProps: {...},
-  TInstance,
+  TInstance: React.ComponentType<TProps>,
 >(
-  Component: component(ref: React.RefSetter<TInstance>, ...TProps),
+  Component: TInstance,
   allowlist: ?AnimatedPropsAllowlist,
-): StrictAnimatedComponentType<TProps, TInstance> {
+): AnimatedComponentType<TProps, React.ElementRef<TInstance>> {
   const useAnimatedProps = createAnimatedPropsHook(allowlist);
 
-  const AnimatedComponent = React.forwardRef<
-    StrictAnimatedProps<TProps>,
-    TInstance,
-  >((props, forwardedRef) => {
-    const [reducedProps, callbackRef] = useAnimatedProps<TProps, TInstance>(
-      props,
-    );
-    const ref = useMergeRefs<TInstance>(callbackRef, forwardedRef);
+  const AnimatedComponent: AnimatedComponentType<
+    TProps,
+    React.ElementRef<TInstance>,
+  > = React.forwardRef<AnimatedProps<TProps>, React.ElementRef<TInstance>>(
+    (props, forwardedRef) => {
+      const [reducedProps, callbackRef] = useAnimatedProps<
+        TProps,
+        React.ElementRef<TInstance>,
+      >(props);
+      const ref = useMergeRefs<React.ElementRef<TInstance>>(
+        callbackRef,
+        forwardedRef,
+      );
 
-    // Some components require explicit passthrough values for animation
-    // to work properly. For example, if an animated component is
-    // transformed and Pressable, onPress will not work after transform
-    // without these passthrough values.
-    // $FlowFixMe[prop-missing]
-    const {passthroughAnimatedPropExplicitValues, style} = reducedProps;
-    const passthroughStyle = passthroughAnimatedPropExplicitValues?.style;
-    const mergedStyle = useMemo(
-      () => composeStyles(style, passthroughStyle),
-      [passthroughStyle, style],
-    );
+      // Some components require explicit passthrough values for animation
+      // to work properly. For example, if an animated component is
+      // transformed and Pressable, onPress will not work after transform
+      // without these passthrough values.
+      // $FlowFixMe[prop-missing]
+      const {passthroughAnimatedPropExplicitValues, style} = reducedProps;
+      const passthroughStyle = passthroughAnimatedPropExplicitValues?.style;
+      const mergedStyle = useMemo(
+        () => composeStyles(style, passthroughStyle),
+        [passthroughStyle, style],
+      );
 
-    // NOTE: It is important that `passthroughAnimatedPropExplicitValues` is
-    // spread after `reducedProps` but before `style`.
-    return (
-      <Component
-        {...reducedProps}
-        {...passthroughAnimatedPropExplicitValues}
-        style={mergedStyle}
-        ref={ref}
-      />
-    );
-  });
+      // NOTE: It is important that `passthroughAnimatedPropExplicitValues` is
+      // spread after `reducedProps` but before `style`.
+      return (
+        <Component
+          {...reducedProps}
+          {...passthroughAnimatedPropExplicitValues}
+          style={mergedStyle}
+          ref={ref}
+        />
+      );
+    },
+  );
 
   AnimatedComponent.displayName = `Animated(${
     Component.displayName || 'Anonymous'

package/Libraries/Animated/nodes/AnimatedNode.js

@@ -28,7 +28,7 @@ let _assertNativeAnimatedModule: ?() => void = () => {
 };
 
 export default class AnimatedNode {
-  #listeners: Map<string, ValueListenerCallback> = new Map();
+  #listeners: Map<string, ValueListenerCallback>;
 
   _platformConfig: ?PlatformConfig = undefined;
 
@@ -38,6 +38,7 @@ export default class AnimatedNode {
       ...
     }>,
   ) {
+    this.#listeners = new Map();
     if (__DEV__) {
       this.__debugID = config?.debugID;
     }
@@ -111,8 +112,8 @@ export default class AnimatedNode {
     return this.#listeners.size > 0;
   }
 
-  __onAnimatedValueUpdateReceived(value: number): void {
-    this.__callListeners(value);
+  __onAnimatedValueUpdateReceived(value: number, offset: number): void {
+    this.__callListeners(value + offset);
   }
 
   __callListeners(value: number): void {

package/Libraries/Animated/nodes/AnimatedProps.js

@@ -22,9 +22,15 @@ import invariant from 'invariant';
 
 export type AnimatedPropsAllowlist = $ReadOnly<{
   style?: ?AnimatedStyleAllowlist,
-  [string]: true,
+  [key: string]: true | AnimatedStyleAllowlist,
 }>;
 
+type TargetView = {
+  +instance: TargetViewInstance,
+  connectedViewTag: ?number,
+};
+type TargetViewInstance = React.ElementRef<React.ElementType>;
+
 function createAnimatedProps(
   inputProps: {[string]: mixed},
   allowlist: ?AnimatedPropsAllowlist,
@@ -75,11 +81,11 @@ function createAnimatedProps(
 }
 
 export default class AnimatedProps extends AnimatedNode {
-  #animatedView: any = null;
   #callback: () => void;
   #nodeKeys: $ReadOnlyArray<string>;
   #nodes: $ReadOnlyArray<AnimatedNode>;
   #props: {[string]: mixed};
+  #target: ?TargetView = null;
 
   constructor(
     inputProps: {[string]: mixed},
@@ -140,6 +146,22 @@ export default class AnimatedProps extends AnimatedNode {
     return props;
   }
 
+  __getNativeAnimatedEventTuples(): $ReadOnlyArray<[string, AnimatedEvent]> {
+    const tuples = [];
+
+    const keys = Object.keys(this.#props);
+    for (let ii = 0, length = keys.length; ii < length; ii++) {
+      const key = keys[ii];
+      const value = this.#props[key];
+
+      if (value instanceof AnimatedEvent && value.__isNative) {
+        tuples.push([key, value]);
+      }
+    }
+
+    return tuples;
+  }
+
   __getAnimatedValue(): Object {
     const props: {[string]: mixed} = {};
 
@@ -164,10 +186,10 @@ export default class AnimatedProps extends AnimatedNode {
   }
 
   __detach(): void {
-    if (this.__isNative && this.#animatedView) {
-      this.__disconnectAnimatedView();
+    if (this.__isNative && this.#target != null) {
+      this.#disconnectAnimatedView(this.#target);
     }
-    this.#animatedView = null;
+    this.#target = null;
 
     const nodes = this.#nodes;
     for (let ii = 0, length = nodes.length; ii < length; ii++) {
@@ -193,56 +215,54 @@ export default class AnimatedProps extends AnimatedNode {
       this.__isNative = true;
 
       // Since this does not call the super.__makeNative, we need to store the
-      // supplied platformConfig here, before calling __connectAnimatedView
+      // supplied platformConfig here, before calling #connectAnimatedView
       // where it will be needed to traverse the graph of attached values.
       super.__setPlatformConfig(platformConfig);
 
-      if (this.#animatedView) {
-        this.__connectAnimatedView();
+      if (this.#target != null) {
+        this.#connectAnimatedView(this.#target);
       }
     }
   }
 
-  setNativeView(animatedView: any): void {
-    if (this.#animatedView === animatedView) {
+  setNativeView(instance: TargetViewInstance): void {
+    if (this.#target?.instance === instance) {
       return;
     }
-    this.#animatedView = animatedView;
+    this.#target = {instance, connectedViewTag: null};
     if (this.__isNative) {
-      this.__connectAnimatedView();
+      this.#connectAnimatedView(this.#target);
     }
   }
 
-  __connectAnimatedView(): void {
+  #connectAnimatedView(target: TargetView): void {
     invariant(this.__isNative, 'Expected node to be marked as "native"');
-    let nativeViewTag: ?number = findNodeHandle(this.#animatedView);
-    if (nativeViewTag == null) {
+    let viewTag: ?number = findNodeHandle(target.instance);
+    if (viewTag == null) {
       if (process.env.NODE_ENV === 'test') {
-        nativeViewTag = -1;
+        viewTag = -1;
       } else {
         throw new Error('Unable to locate attached view in the native tree');
       }
     }
     NativeAnimatedHelper.API.connectAnimatedNodeToView(
       this.__getNativeTag(),
-      nativeViewTag,
+      viewTag,
     );
+    target.connectedViewTag = viewTag;
   }
 
-  __disconnectAnimatedView(): void {
+  #disconnectAnimatedView(target: TargetView): void {
     invariant(this.__isNative, 'Expected node to be marked as "native"');
-    let nativeViewTag: ?number = findNodeHandle(this.#animatedView);
-    if (nativeViewTag == null) {
-      if (process.env.NODE_ENV === 'test') {
-        nativeViewTag = -1;
-      } else {
-        throw new Error('Unable to locate attached view in the native tree');
-      }
+    const viewTag = target.connectedViewTag;
+    if (viewTag == null) {
+      return;
     }
     NativeAnimatedHelper.API.disconnectAnimatedNodeFromView(
       this.__getNativeTag(),
-      nativeViewTag,
+      viewTag,
     );
+    target.connectedViewTag = null;
   }
 
   __restoreDefaultValues(): void {

package/Libraries/Animated/nodes/AnimatedValue.js

@@ -10,7 +10,8 @@
 
 import type {EventSubscription} from '../../vendor/emitter/EventEmitter';
 import type {PlatformConfig} from '../AnimatedPlatformConfig';
-import type Animation, {EndCallback} from '../animations/Animation';
+import type Animation from '../animations/Animation';
+import type {EndCallback} from '../animations/Animation';
 import type {InterpolationConfigType} from './AnimatedInterpolation';
 import type AnimatedNode from './AnimatedNode';
 import type {AnimatedNodeConfig} from './AnimatedNode';
@@ -51,7 +52,6 @@ const NativeAnimatedAPI = NativeAnimatedHelper.API;
  * transform which can receive values from multiple parents.
  */
 export function flushValue(rootNode: AnimatedNode): void {
-  // eslint-disable-next-line func-call-spacing
   const leaves = new Set<{update: () => void, ...}>();
   function findAnimatedStyles(node: AnimatedNode) {
     // $FlowFixMe[prop-missing]
@@ -85,8 +85,8 @@ function _executeAsAnimatedBatch(id: string, operation: () => void) {
  * See https://reactnative.dev/docs/animatedvalue
  */
 export default class AnimatedValue extends AnimatedWithChildren {
-  #listenerCount: number = 0;
-  #updateSubscription: ?EventSubscription = null;
+  #listenerCount: number;
+  #updateSubscription: ?EventSubscription;
 
   _value: number;
   _startingValue: number;
@@ -99,6 +99,10 @@ export default class AnimatedValue extends AnimatedWithChildren {
     if (typeof value !== 'number') {
       throw new Error('AnimatedValue: Attempting to set value to undefined');
     }
+
+    this.#listenerCount = 0;
+    this.#updateSubscription = null;
+
     this._startingValue = this._value = value;
     this._offset = 0;
     this._animation = null;
@@ -164,7 +168,7 @@ export default class AnimatedValue extends AnimatedWithChildren {
         'onAnimatedValueUpdate',
         data => {
           if (data.tag === nativeTag) {
-            this.__onAnimatedValueUpdateReceived(data.value);
+            this.__onAnimatedValueUpdateReceived(data.value, data.offset);
           }
         },
       );
@@ -242,7 +246,9 @@ export default class AnimatedValue extends AnimatedWithChildren {
     this._offset += this._value;
     this._value = 0;
     if (this.__isNative) {
-      NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());
+      _executeAsAnimatedBatch(this.__getNativeTag().toString(), () =>
+        NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag()),
+      );
     }
   }
 
@@ -282,8 +288,11 @@ export default class AnimatedValue extends AnimatedWithChildren {
     }
   }
 
-  __onAnimatedValueUpdateReceived(value: number): void {
+  __onAnimatedValueUpdateReceived(value: number, offset?: number): void {
     this._updateValue(value, false /*flush*/);
+    if (offset != null) {
+      this._offset = offset;
+    }
   }
 
   /**

package/Libraries/Animated/nodes/AnimatedValueXY.js

@@ -214,7 +214,9 @@ export default class AnimatedValueXY extends AnimatedWithChildren {
    *
    * See https://reactnative.dev/docs/animatedvaluexy#gettranslatetransform
    */
-  getTranslateTransform(): Array<{[key: string]: AnimatedValue, ...}> {
+  getTranslateTransform(): Array<
+    {translateX: AnimatedValue} | {translateY: AnimatedValue},
+  > {
     return [{translateX: this.x}, {translateY: this.y}];
   }
 

package/Libraries/AppDelegate/RCTAppSetupUtils.h

@@ -32,6 +32,8 @@
 namespace facebook::react {
 class RuntimeScheduler;
 }
+RCT_EXTERN NSArray<NSString *> *RCTAppSetupUnstableModulesRequiringMainQueueSetup(
+    id<RCTDependencyProvider> dependencyProvider);
 
 RCT_EXTERN id<RCTTurboModule> RCTAppSetupDefaultModuleFromClass(
     Class moduleClass,

package/Libraries/AppDelegate/RCTAppSetupUtils.mm

@@ -54,6 +54,12 @@ RCTAppSetupDefaultRootView(RCTBridge *bridge, NSString *moduleName, NSDictionary
   return [[RCTRootView alloc] initWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
 }
 
+NSArray<NSString *> *RCTAppSetupUnstableModulesRequiringMainQueueSetup(id<RCTDependencyProvider> dependencyProvider)
+{
+  // For oss, insert core main queue setup modules here
+  return dependencyProvider ? dependencyProvider.unstableModulesRequiringMainQueueSetup : @[];
+}
+
 id<RCTTurboModule> RCTAppSetupDefaultModuleFromClass(Class moduleClass, id<RCTDependencyProvider> dependencyProvider)
 {
   // private block used to filter out modules depending on protocol conformance

package/Libraries/AppDelegate/RCTArchConfiguratorProtocol.h

@@ -15,22 +15,22 @@ NS_ASSUME_NONNULL_BEGIN
 ///
 /// @note: This is required to be rendering on Fabric (i.e. on the New Architecture).
 /// @return: `true` if the Turbo Native Module are enabled. Otherwise, it returns `false`.
-- (BOOL)turboModuleEnabled __attribute__((deprecated("Use newArchEnabled instead")));
+- (BOOL)turboModuleEnabled __attribute__((deprecated("Use RCTIsNewArchEnabled instead")));
 
 /// This method controls whether the App will use the Fabric renderer of the New Architecture or not.
 ///
 /// @return: `true` if the Fabric Renderer is enabled. Otherwise, it returns `false`.
-- (BOOL)fabricEnabled __attribute__((deprecated("Use newArchEnabled instead")));
+- (BOOL)fabricEnabled __attribute__((deprecated("Use RCTIsNewArchEnabled instead")));
 
 /// This method controls whether React Native's new initialization layer is enabled.
 ///
 /// @return: `true` if the new initialization layer is enabled. Otherwise returns `false`.
-- (BOOL)bridgelessEnabled __attribute__((deprecated("Use newArchEnabled instead")));
+- (BOOL)bridgelessEnabled __attribute__((deprecated("Use RCTIsNewArchEnabled instead")));
 
 /// This method controls whether React Native uses new Architecture.
 ///
 /// @return: `true` if the new architecture is enabled. Otherwise returns `false`.
-- (BOOL)newArchEnabled;
+- (BOOL)newArchEnabled __attribute__((deprecated("Use RCTIsNewArchEnabled instead")));
 @end
 
 NS_ASSUME_NONNULL_END