react-native-reanimated 3.0.0-rc.9 → 3.0.1

package/react-native-reanimated.d.ts

@@ -4,7 +4,6 @@
 declare module 'react-native-reanimated' {
   import {
     ComponentClass,
-    ReactNode,
     Component,
     RefObject,
     FunctionComponent,
@@ -58,25 +57,6 @@ declare module 'react-native-reanimated' {
     import('./lib/types/lib/reanimated2/commonTypes').MeasuredDimensions;
 
   namespace Animated {
-    type Nullable<T> = T | null | undefined;
-    class AnimatedNode<T> {
-      constructor(
-        nodeConfig: object,
-        inputNodes?: ReadonlyArray<AnimatedNode<any>>
-      );
-
-      isNativelyInitialized(): boolean;
-      /**
-       * ' __value' is not available at runtime on AnimatedNode<T>. It is
-       * necessary to have some discriminating property on a type to know that
-       * an AnimatedNode<number> and AnimatedNode<string> are not compatible types.
-       */
-      ' __value': T;
-    }
-    class AnimatedClock extends AnimatedNode<number> {
-      constructor();
-    }
-
     export enum Extrapolate {
       EXTEND = 'extend',
       CLAMP = 'clamp',
@@ -95,36 +75,13 @@ declare module 'react-native-reanimated' {
       extrapolateRight?: Extrapolate;
     }
     type Value = string | number | boolean;
-    class AnimatedValue<T extends Value> extends AnimatedNode<T> {
-      constructor(value?: T);
-
-      setValue(value: Adaptable<T>): void;
-
-      interpolate(config: InterpolationConfig): AnimatedNode<number>;
-    }
-    export interface AnimationState {
-      finished: AnimatedValue<number>;
-      position: AnimatedValue<number>;
-      time: AnimatedValue<number>;
-    }
 
     export type SharedValue<T> = { value: T };
     export type DerivedValue<T> = Readonly<SharedValue<T>>;
-    export type Mapping = { [key: string]: Mapping } | Adaptable<any>;
     export type Adaptable<T> =
       | T
-      | AnimatedNode<T>
-      | ReadonlyArray<T | AnimatedNode<T> | ReadonlyArray<T | AnimatedNode<T>>>;
-    type BinaryOperator<T = number> = (
-      left: Adaptable<number>,
-      right: Adaptable<number>
-    ) => AnimatedNode<T>;
-    type UnaryOperator = (value: Adaptable<number>) => AnimatedNode<number>;
-    type MultiOperator<T = number> = (
-      a: Adaptable<number>,
-      b: Adaptable<number>,
-      ...others: Adaptable<number>[]
-    ) => AnimatedNode<T>;
+      | ReadonlyArray<T | ReadonlyArray<T>>
+      | SharedValue<T>;
 
     export type TransformStyleTypes = TransformsStyle['transform'] extends
       | readonly (infer T)[]
@@ -145,12 +102,7 @@ declare module 'react-native-reanimated' {
         ? AnimateStyle<S[K]>
         : S[K] extends ColorValue | undefined
         ? S[K] | number
-        :
-            | S[K]
-            | AnimatedNode<
-                // allow `number` where `string` normally is to support colors
-                S[K] extends ColorValue | undefined ? S[K] | number : S[K]
-              >;
+        : S[K] | SharedValue<AnimatableValue>;
     };
 
     export type StylesOrDefault<T> = 'style' extends keyof T
@@ -158,7 +110,7 @@ declare module 'react-native-reanimated' {
       : Record<string, unknown>;
 
     export type AnimateProps<P extends object> = {
-      [K in keyof Omit<P, 'style'>]: P[K] | AnimatedNode<P[K]>;
+      [K in keyof Omit<P, 'style'>]: P[K] | SharedValue<P[K]>;
     } & {
       style?: StyleProp<AnimateStyle<StylesOrDefault<P>>>;
     } & {
@@ -177,82 +129,8 @@ declare module 'react-native-reanimated' {
         | typeof BaseAnimationBuilder
         | EntryExitAnimationFunction
         | Keyframe;
-    };
-
-    export interface PhysicsAnimationState extends AnimationState {
-      velocity: AnimatedValue<number>;
-    }
-
-    export type DecayState = PhysicsAnimationState;
-
-    export interface DecayConfig {
-      deceleration: Adaptable<number>;
-    }
-    export interface BackwardCompatibleWrapper {
-      start: (callback?: (data: { finished: boolean }) => any) => void;
-      stop: () => void;
-    }
-
-    export interface TimingState extends AnimationState {
-      frameTime: AnimatedValue<number>;
-    }
-    export type EasingNodeFunction = (
-      value: Adaptable<number>
-    ) => AnimatedNode<number>;
-    export type EasingFunction = (value: number) => number;
-    export interface TimingConfig {
-      toValue: Adaptable<number>;
-      duration: Adaptable<number>;
-      easing: EasingNodeFunction;
-    }
-
-    export type SpringState = PhysicsAnimationState;
-
-    export interface SpringConfig {
-      damping: Adaptable<number>;
-      mass: Adaptable<number>;
-      stiffness: Adaptable<number>;
-      overshootClamping: Adaptable<number> | boolean;
-      restSpeedThreshold: Adaptable<number>;
-      restDisplacementThreshold: Adaptable<number>;
-      toValue: Adaptable<number>;
-    }
-    interface SpringConfigWithOrigamiTensionAndFriction {
-      tension: Adaptable<number>;
-      mass: Adaptable<number>;
-      friction: Adaptable<number>;
-      overshootClamping: Adaptable<number> | boolean;
-      restSpeedThreshold: Adaptable<number>;
-      restDisplacementThreshold: Adaptable<number>;
-      toValue: Adaptable<number>;
-    }
-
-    interface SpringConfigWithBouncinessAndSpeed {
-      bounciness: Adaptable<number>;
-      mass: Adaptable<number>;
-      speed: Adaptable<number>;
-      overshootClamping: Adaptable<number> | boolean;
-      restSpeedThreshold: Adaptable<number>;
-      restDisplacementThreshold: Adaptable<number>;
-      toValue: Adaptable<number>;
-    }
-
-    type SpringUtils = {
-      makeDefaultConfig: () => SpringConfig;
-      makeConfigFromBouncinessAndSpeed: (
-        prevConfig: SpringConfigWithBouncinessAndSpeed
-      ) => SpringConfig;
-      makeConfigFromOrigamiTensionAndFriction: (
-        prevConfig: SpringConfigWithOrigamiTensionAndFriction
-      ) => SpringConfig;
-    };
-
-    export const SpringUtils: SpringUtils;
-
-    type CodeProps = {
-      exec?: AnimatedNode<number>;
-      children?: () => AnimatedNode<number>;
-      dependencies?: Array<any>;
+      sharedTransitionTag?: string;
+      sharedTransitionStyle?: ILayoutAnimationBuilder;
     };
 
     // components
@@ -276,10 +154,12 @@ declare module 'react-native-reanimated' {
     }
     // eslint-disable-next-line @typescript-eslint/no-empty-interface
     export interface ScrollView extends ReactNativeScrollView {}
-
-    export class Code extends Component<CodeProps> {}
-    export class FlatList<T> extends Component<AnimateProps<FlatListProps<T>>> {
-      itemLayoutAnimation: ILayoutAnimationBuilder;
+    export interface FlatListPropsWithLayout<T> extends FlatListProps<T> {
+      itemLayoutAnimation?: ILayoutAnimationBuilder;
+    }
+    export class FlatList<T> extends Component<
+      AnimateProps<FlatListPropsWithLayout<T>>
+    > {
       getNode(): ReactNativeFlatList;
     }
     // eslint-disable-next-line @typescript-eslint/no-empty-interface
@@ -297,164 +177,6 @@ declare module 'react-native-reanimated' {
       options?: Options<P>
     ): FunctionComponent<AnimateProps<P>>;
 
-    // classes
-    export {
-      AnimatedClock as Clock,
-      AnimatedNode as Node,
-      AnimatedValue as Value,
-    };
-
-    // base operations
-    export const add: MultiOperator;
-    export const sub: MultiOperator;
-    export const multiply: MultiOperator;
-    export const divide: MultiOperator;
-    export const pow: MultiOperator;
-    export const modulo: MultiOperator;
-    export const sqrt: UnaryOperator;
-    export const log: UnaryOperator;
-    export const sin: UnaryOperator;
-    export const cos: UnaryOperator;
-    export const tan: UnaryOperator;
-    export const acos: UnaryOperator;
-    export const asin: UnaryOperator;
-    export const atan: UnaryOperator;
-    export const exp: UnaryOperator;
-    export const round: UnaryOperator;
-    export const floor: UnaryOperator;
-    export const ceil: UnaryOperator;
-    export const lessThan: BinaryOperator<0 | 1>;
-    export const eq: BinaryOperator<0 | 1>;
-    export const greaterThan: BinaryOperator<0 | 1>;
-    export const lessOrEq: BinaryOperator<0 | 1>;
-    export const greaterOrEq: BinaryOperator<0 | 1>;
-    export const neq: BinaryOperator<0 | 1>;
-    export const and: MultiOperator<0 | 1>;
-    export const or: MultiOperator<0 | 1>;
-    export function proc<T extends (Adaptable<Value> | undefined)[]>(
-      func: (...args: T) => AnimatedNode<number>
-    ): typeof func;
-    export function defined(value: Adaptable<any>): AnimatedNode<0 | 1>;
-    export function not(value: Adaptable<any>): AnimatedNode<0 | 1>;
-    export function set<T extends Value>(
-      valueToBeUpdated: AnimatedValue<T>,
-      sourceNode: Adaptable<T>
-    ): AnimatedNode<T>;
-    export function concat(
-      ...args: Array<Adaptable<string> | Adaptable<number>>
-    ): AnimatedNode<string>;
-    export function cond<T1 extends Value = number, T2 extends Value = number>(
-      conditionNode: Adaptable<number>,
-      ifNode: Adaptable<T1>,
-      elseNode?: Adaptable<T2>
-    ): AnimatedNode<T1 | T2>;
-    export function block<T1 extends Value = number, T2 extends Value = any>(
-      items: ReadonlyArray<Adaptable<T2>>
-    ): AnimatedNode<T1>;
-    export function call<T>(
-      args: ReadonlyArray<T | AnimatedNode<T>>,
-      callback: (args: ReadonlyArray<T>) => void
-    ): AnimatedNode<0>;
-    export function debug<T>(
-      message: string,
-      value: AnimatedNode<T>
-    ): AnimatedNode<T>;
-    export function onChange(
-      value: Adaptable<number>,
-      action: Adaptable<number>
-    ): AnimatedNode<number>;
-    export function startClock(clock: AnimatedClock): AnimatedNode<0>;
-    export function stopClock(clock: AnimatedClock): AnimatedNode<0>;
-    export function clockRunning(clock: AnimatedClock): AnimatedNode<0 | 1>;
-    // the return type for `event` is a lie, but it's the same lie that
-    // react-native makes within Animated
-    type EventArgFunc<T> = (arg: T) => AnimatedNode<number>;
-    type EventMapping<T> = T extends object
-      ? { [K in keyof T]?: EventMapping<T[K]> | EventArgFunc<T[K]> }
-      : Adaptable<T> | EventArgFunc<T>;
-    type EventMappingArray<T> = T extends Array<any>
-      ? { [I in keyof T]: EventMapping<T[I]> }
-      : [EventMapping<T>];
-    export function event<T>(
-      argMapping: T extends never
-        ? ReadonlyArray<Mapping>
-        : Readonly<EventMappingArray<T>>,
-      config?: {}
-    ): (...args: any[]) => void;
-
-    // derived operations
-    export function abs(value: Adaptable<number>): AnimatedNode<number>;
-    export function acc(value: Adaptable<number>): AnimatedNode<number>;
-    export function color(
-      r: Adaptable<number>,
-      g: Adaptable<number>,
-      b: Adaptable<number>,
-      a?: Adaptable<number>
-    ): AnimatedNode<number | string>;
-    export function diff(value: Adaptable<number>): AnimatedNode<number>;
-    export function diffClamp(
-      value: Adaptable<number>,
-      minVal: Adaptable<number>,
-      maxVal: Adaptable<number>
-    ): AnimatedNode<number>;
-    export function interpolateNode(
-      value: Adaptable<number>,
-      config: InterpolationConfig
-    ): AnimatedNode<number>;
-    export function interpolateColors<T extends string | number>(
-      animationValue: Adaptable<number>,
-      {
-        inputRange,
-        outputColorRange,
-      }: {
-        inputRange: ReadonlyArray<Adaptable<number>>;
-        outputColorRange: ReadonlyArray<Adaptable<T>>;
-      }
-    ): AnimatedNode<T>;
-    export const max: BinaryOperator;
-    export const min: BinaryOperator;
-
-    // animations
-    export function decay(
-      clock: AnimatedClock,
-      state: DecayState,
-      config: DecayConfig
-    ): AnimatedNode<number>;
-    export function timing(
-      clock: AnimatedClock,
-      state: TimingState,
-      config: TimingConfig
-    ): AnimatedNode<number>;
-    export function spring(
-      clock: AnimatedClock,
-      state: SpringState,
-      config: SpringConfig
-    ): AnimatedNode<number>;
-    // backward compatible API
-    export function spring(
-      node: AnimatedNode<number>,
-      config: SpringConfig
-    ): BackwardCompatibleWrapper;
-    export function timing(
-      node: AnimatedNode<number>,
-      config: TimingConfig
-    ): BackwardCompatibleWrapper;
-    export function decay(
-      node: AnimatedNode<number>,
-      config: DecayConfig
-    ): BackwardCompatibleWrapper;
-
-    // hooks
-    export function useCode(
-      exec: () =>
-        | Nullable<AnimatedNode<number>[] | AnimatedNode<number>>
-        | boolean,
-      deps: Array<any>
-    ): void;
-    export function useValue<T extends Value>(
-      initialValue: T
-    ): AnimatedValue<T>;
-
     // configuration
     export function addWhitelistedNativeProps(props: {
       [key: string]: true;
@@ -467,7 +189,6 @@ declare module 'react-native-reanimated' {
   export type SharedValue<T> = Animated.SharedValue<T>;
   export type AnimateStyle<S> = Animated.AnimateStyle<S>;
   export type DerivedValue<T> = Animated.DerivedValue<T>;
-  export type Mapping = Animated.Mapping;
   export type Adaptable<T> = Animated.Adaptable<T>;
   export type TransformStyleTypes = Animated.TransformStyleTypes;
   export type AdaptTransforms<T> = Animated.AdaptTransforms<T>;
@@ -496,14 +217,25 @@ declare module 'react-native-reanimated' {
     ROTATION = 5,
   }
 
-  export type SensorConfig = {
+  export enum IOSReferenceFrame {
+    XArbitraryZVertical = 0,
+    XArbitraryCorrectedZVertical = 1,
+    XMagneticNorthZVertical = 2,
+    XTrueNorthZVertical = 3,
+    Auto = 4,
+  }
+
+  export type SensorConfig = Partial<{
     interval: number | 'auto';
-  };
+    adjustToInterfaceOrientation: boolean;
+    iosReferenceFrame: IOSReferenceFrame;
+  }>;
 
   export type Value3D = {
     x: number;
     y: number;
     z: number;
+    interfaceOrientation: InterfaceOrientation;
   };
 
   export type SensorValue3D = SharedValue<Value3D>;
@@ -516,6 +248,7 @@ declare module 'react-native-reanimated' {
     yaw: number;
     pitch: number;
     roll: number;
+    interfaceOrientation: InterfaceOrientation;
   };
 
   export type SensorValueRotation = SharedValue<ValueRotation>;
@@ -566,7 +299,14 @@ declare module 'react-native-reanimated' {
     height: SharedValue<number>;
     state: SharedValue<KeyboardState>;
   };
-  export function useAnimatedKeyboard(): AnimatedKeyboardInfo;
+
+  export interface AnimatedKeyboardOptions {
+    isStatusBarTranslucentAndroid?: boolean;
+  }
+
+  export function useAnimatedKeyboard(
+    options?: AnimatedKeyboardOptions
+  ): AnimatedKeyboardInfo;
 
   export function useScrollViewOffset(
     aref: RefObject<Animated.ScrollView>
@@ -715,11 +455,19 @@ declare module 'react-native-reanimated' {
 
   export function processColor(color: number | string): number;
 
+  export type InterpolationOptions = {
+    gamma?: number;
+    useCorrectedHSVInterpolation?: boolean;
+  };
+
+  export function isColor(value: unknown): boolean;
+
   export function interpolateColor<T extends string | number>(
     value: number,
     inputRange: readonly number[],
     outputRange: readonly T[],
-    colorSpace?: 'RGB' | 'HSV'
+    colorSpace?: 'RGB' | 'HSV',
+    options?: InterpolationOptions
   ): T;
 
   export enum ColorSpace {
@@ -750,7 +498,8 @@ declare module 'react-native-reanimated' {
   export function useInterpolateConfig(
     inputRange: readonly number[],
     outputRange: readonly (string | number)[],
-    colorSpace?: ColorSpace
+    colorSpace?: ColorSpace,
+    options?: InterpolationOptions
   ): SharedValue<InterpolateConfig>;
 
   export function interpolateSharableColor(
@@ -1081,32 +830,6 @@ declare module 'react-native-reanimated' {
   export class RollInRight extends ComplexAnimationBuilder {}
   export class RollOutLeft extends ComplexAnimationBuilder {}
   export class RollOutRight extends ComplexAnimationBuilder {}
-  interface EasingNodeStatic {
-    linear: Animated.EasingNodeFunction;
-    ease: Animated.EasingNodeFunction;
-    quad: Animated.EasingNodeFunction;
-    cubic: Animated.EasingNodeFunction;
-    poly(n: Animated.Adaptable<number>): Animated.EasingNodeFunction;
-    sin: Animated.EasingNodeFunction;
-    circle: Animated.EasingNodeFunction;
-    exp: Animated.EasingNodeFunction;
-    elastic(
-      bounciness?: Animated.Adaptable<number>
-    ): Animated.EasingNodeFunction;
-    back(s?: Animated.Adaptable<number>): Animated.EasingNodeFunction;
-    bounce: Animated.EasingNodeFunction;
-    bezier(
-      x1: number,
-      y1: number,
-      x2: number,
-      y2: number
-    ): Animated.EasingNodeFunction;
-    in(easing: Animated.EasingNodeFunction): Animated.EasingNodeFunction;
-    out(easing: Animated.EasingNodeFunction): Animated.EasingNodeFunction;
-    inOut(easing: Animated.EasingNodeFunction): Animated.EasingNodeFunction;
-  }
-
-  export const EasingNode: EasingNodeStatic;
 
   interface EasingStatic {
     linear: Animated.EasingFunction;
@@ -1139,103 +862,18 @@ declare module 'react-native-reanimated' {
 
   export const Easing: EasingStatic;
 
-  export interface TransitioningViewProps extends ViewProps {
-    transition: ReactNode;
-  }
-
-  export class TransitioningView extends Component<TransitioningViewProps> {
-    animateNextTransition(): void;
-  }
+  export function enableLayoutAnimations(flag: boolean): void;
 
-  export class Transitioning extends Component {
-    static View: typeof TransitioningView;
-  }
+  export const Extrapolate: typeof Animated.Extrapolate;
 
-  export interface TransitionProps {
-    delayMs?: number;
-    durationMs?: number;
-    interpolation?: 'linear' | 'easeIn' | 'easeOut' | 'easeInOut';
-    propagation?: 'top' | 'bottom' | 'left' | 'right';
-  }
+  type AnimationFactoryType = (values: LayoutAnimationsValues) => StyleProps;
 
-  export interface TransitionInOutProps extends TransitionProps {
-    type?:
-      | 'fade'
-      | 'scale'
-      | 'slide-top'
-      | 'slide-bottom'
-      | 'slide-right'
-      | 'slide-left';
-  }
-  export class Transition extends Component {
-    static In: ComponentClass<TransitionInOutProps>;
-    static Out: ComponentClass<TransitionInOutProps>;
-    static Change: ComponentClass<TransitionProps>;
-    static Together: ComponentClass<{}>;
-    static Sequence: ComponentClass<{}>;
+  export class SharedTransition implements ILayoutAnimationBuilder {
+    animationFactory: AnimationFactoryType | null = null;
+    static createInstance(): SharedTransition;
+    static custom(animationFactory: AnimationFactoryType): SharedTransition;
+    custom(animationFactory: AnimationFactoryType): SharedTransition;
+    static build(): LayoutAnimationFunction;
+    build(): LayoutAnimationFunction;
   }
-
-  export class Clock extends Animated.Clock {}
-  export class Value<
-    T extends string | number | boolean
-  > extends Animated.Value<T> {}
-  export class Node<T> extends Animated.Node<T> {}
-  export const add: typeof Animated.add;
-  export const sub: typeof Animated.sub;
-  export const multiply: typeof Animated.multiply;
-  export const divide: typeof Animated.divide;
-  export const pow: typeof Animated.pow;
-  export const modulo: typeof Animated.modulo;
-  export const sqrt: typeof Animated.sqrt;
-  export const log: typeof Animated.log;
-  export const sin: typeof Animated.sin;
-  export const cos: typeof Animated.cos;
-  export const exp: typeof Animated.exp;
-  export const round: typeof Animated.round;
-  export const lessThan: typeof Animated.lessThan;
-  export const eq: typeof Animated.eq;
-  export const greaterThan: typeof Animated.greaterThan;
-  export const lessOrEq: typeof Animated.lessOrEq;
-  export const greaterOrEq: typeof Animated.greaterOrEq;
-  export const neq: typeof Animated.neq;
-  export const and: typeof Animated.and;
-  export const or: typeof Animated.or;
-  export const defined: typeof Animated.defined;
-  export const not: typeof Animated.not;
-  export const tan: typeof Animated.tan;
-  export const acos: typeof Animated.acos;
-  export const asin: typeof Animated.asin;
-  export const atan: typeof Animated.atan;
-  export const proc: typeof Animated.proc;
-  export const block: typeof Animated.block;
-  export const concat: typeof Animated.concat;
-  export const event: typeof Animated.event;
-  export const call: typeof Animated.call;
-  export const debug: typeof Animated.debug;
-  export const clockRunning: typeof Animated.clockRunning;
-  export const stopClock: typeof Animated.stopClock;
-  export const startClock: typeof Animated.startClock;
-  export const set: typeof Animated.set;
-  export const cond: typeof Animated.cond;
-  export const abs: typeof Animated.abs;
-  export const acc: typeof Animated.acc;
-  export const color: typeof Animated.color;
-  export const interpolateColors: typeof Animated.interpolateColors;
-  export const diff: typeof Animated.diff;
-  export const diffClamp: typeof Animated.diffClamp;
-  export const interpolateNode: typeof Animated.interpolateNode;
-  export const Extrapolate: typeof Animated.Extrapolate;
-  export const max: typeof Animated.max;
-  export const min: typeof Animated.min;
-  export const onChange: typeof Animated.onChange;
-  export const floor: typeof Animated.floor;
-  export const ceil: typeof Animated.ceil;
-  export const useCode: typeof Animated.useCode;
-  export const decay: typeof Animated.decay;
-  export const timing: typeof Animated.timing;
-  export const spring: typeof Animated.spring;
-  export const SpringUtils: typeof Animated.SpringUtils;
-  export const useValue: typeof Animated.useValue;
-  export const ReverseAnimation: typeof Animated.ReverseAnimation;
-  export function enableLayoutAnimations(flag: boolean): void;
 }

package/scripts/reanimated_utils.rb

@@ -1,6 +1,6 @@
 def try_to_parse_react_native_package_json(node_modules_dir)
   react_native_package_json_path = File.join(node_modules_dir, 'react-native/package.json')
-  if !File.exists?(react_native_package_json_path)
+  if !File.exist?(react_native_package_json_path)
     return nil
   end
   return JSON.parse(File.read(react_native_package_json_path))
@@ -34,6 +34,9 @@ def find_config()
   result[:is_tvos_target] = react_native_json['name'] == 'react-native-tvos'
   result[:react_native_version] = react_native_json['version']
   result[:react_native_minor_version] = react_native_json['version'].split('.')[1].to_i
+  if result[:react_native_minor_version] == 0 # nightly
+    result[:react_native_minor_version] = 1000
+  end
   result[:react_native_node_modules_dir] = File.expand_path(react_native_node_modules_dir)
   result[:reanimated_node_modules_dir] = File.expand_path(File.join(__dir__, '..', '..'))
 
@@ -65,7 +68,7 @@ def assert_no_multiple_instances(react_native_info)
       location['/package.json'] = ''
       parsed_location += "- " + location + "\n"
     end
-    raise "[react-native-reanimated] Multiple versions of Reanimated were detected. Only one instance of react-native-reanimated can be installed in a project. You need to resolve the conflict manually. Check out the documentation: https://docs.swmansion.com/react-native-reanimated/docs/next/fundamentals/troubleshooting#multiple-versions-of-reanimated-were-detected \n\nConflict between: \n" + parsed_location
+    raise "[react-native-reanimated] Multiple versions of Reanimated were detected. Only one instance of react-native-reanimated can be installed in a project. You need to resolve the conflict manually. Check out the documentation: https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/troubleshooting/#multiple-versions-of-reanimated-were-detected \n\nConflict between: \n" + parsed_location
   end
 end
 
@@ -76,3 +79,13 @@ def assert_no_reanimated2_with_new_architecture(reanimated_package_json)
     raise "[react-native-reanimated] Reanimated 2.x does not support Fabric. Please upgrade to 3.x to use Reanimated with the New Architecture. For details, see https://blog.swmansion.com/announcing-reanimated-3-16167428c5f7"
   end
 end
+
+def assert_latest_react_native_with_new_architecture(config, reanimated_package_json)
+  reanimated_version = reanimated_package_json['version']
+  reanimated_major_version = reanimated_version.split('.')[0].to_i
+  react_native_minor_version = config[:react_native_minor_version]
+  fabric_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+  if fabric_enabled && reanimated_major_version == 3 && react_native_minor_version < 71
+    raise "[react-native-reanimated] Reanimated " + reanimated_version + " supports the New Architecture only on the latest minor release of React Native. Please upgrade to React Native 0.71.0+ or downgrade to an older version of Reanimated v3"
+  end
+end