react-native-reanimated 2.5.0 → 2.6.0

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/Zoom.d.ts

@@ -0,0 +1,66 @@
+import { IEntryExitAnimationBuilder, EntryExitAnimationFunction, EntryAnimationsValues, ExitAnimationsValues, AnimationConfigFunction, IEntryAnimationBuilder, IExitAnimationBuilder } from '../animationBuilder/commonTypes';
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export declare class ZoomIn extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomIn;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomInRotate extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomInRotate;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomInLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomInLeft;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomInRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomInRight;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomInUp extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomInUp;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomInDown extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomInDown;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomInEasyUp extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): ZoomInEasyUp;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class ZoomInEasyDown extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): ZoomInEasyDown;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class ZoomOut extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomOut;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomOutRotate extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomOutRotate;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomOutLeft extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomOutLeft;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomOutRight extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomOutRight;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomOutUp extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomOutUp;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomOutDown extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): ZoomOutDown;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class ZoomOutEasyUp extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): ZoomOutEasyUp;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class ZoomOutEasyDown extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): ZoomOutEasyDown;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultAnimations/index.d.ts

@@ -0,0 +1,10 @@
+export * from './Flip';
+export * from './Stretch';
+export * from './Fade';
+export * from './Slide';
+export * from './Zoom';
+export * from './Bounce';
+export * from './Lightspeed';
+export * from './Pinwheel';
+export * from './Rotate';
+export * from './Roll';

package/lib/types/lib/reanimated2/layoutReanimation/defaultTransitions/CurvedTransition.d.ts

@@ -0,0 +1,19 @@
+import { ILayoutAnimationBuilder, LayoutAnimationFunction } from '../animationBuilder/commonTypes';
+import { BaseAnimationBuilder } from '../animationBuilder';
+import { EasingFn } from '../../Easing';
+export declare class CurvedTransition extends BaseAnimationBuilder implements ILayoutAnimationBuilder {
+    easingXV: EasingFn;
+    easingYV: EasingFn;
+    easingWidthV: EasingFn;
+    easingHeightV: EasingFn;
+    static createInstance(): CurvedTransition;
+    static easingX(easing: EasingFn): CurvedTransition;
+    easingX(easing: EasingFn): CurvedTransition;
+    static easingY(easing: EasingFn): CurvedTransition;
+    easingY(easing: EasingFn): CurvedTransition;
+    static easingWidth(easing: EasingFn): CurvedTransition;
+    easingWidth(easing: EasingFn): CurvedTransition;
+    static easingHeight(easing: EasingFn): CurvedTransition;
+    easingHeight(easing: EasingFn): CurvedTransition;
+    build: () => LayoutAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultTransitions/EntryExitTransition.d.ts

@@ -0,0 +1,13 @@
+import { ILayoutAnimationBuilder, LayoutAnimationFunction } from '../animationBuilder/commonTypes';
+import { BaseAnimationBuilder } from '../animationBuilder';
+export declare class EntryExitTransition extends BaseAnimationBuilder implements ILayoutAnimationBuilder {
+    enteringV: BaseAnimationBuilder | typeof BaseAnimationBuilder;
+    exitingV: BaseAnimationBuilder | typeof BaseAnimationBuilder;
+    static createInstance(): EntryExitTransition;
+    static entering(animation: BaseAnimationBuilder | typeof BaseAnimationBuilder): EntryExitTransition;
+    entering(animation: BaseAnimationBuilder | typeof BaseAnimationBuilder): EntryExitTransition;
+    static exiting(animation: BaseAnimationBuilder | typeof BaseAnimationBuilder): EntryExitTransition;
+    exiting(animation: BaseAnimationBuilder | typeof BaseAnimationBuilder): EntryExitTransition;
+    build: () => LayoutAnimationFunction;
+}
+export declare function combineTransition(exiting: BaseAnimationBuilder | typeof BaseAnimationBuilder, entering: BaseAnimationBuilder | typeof BaseAnimationBuilder): EntryExitTransition;

package/lib/types/lib/reanimated2/layoutReanimation/defaultTransitions/FadingTransition.d.ts

@@ -0,0 +1,6 @@
+import { ILayoutAnimationBuilder, LayoutAnimationFunction } from '../animationBuilder/commonTypes';
+import { BaseAnimationBuilder } from '../animationBuilder';
+export declare class FadingTransition extends BaseAnimationBuilder implements ILayoutAnimationBuilder {
+    static createInstance(): FadingTransition;
+    build: () => LayoutAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultTransitions/JumpingTransition.d.ts

@@ -0,0 +1,6 @@
+import { ILayoutAnimationBuilder, LayoutAnimationFunction } from '../animationBuilder/commonTypes';
+import { BaseAnimationBuilder } from '../animationBuilder';
+export declare class JumpingTransition extends BaseAnimationBuilder implements ILayoutAnimationBuilder {
+    static createInstance(): JumpingTransition;
+    build: () => LayoutAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultTransitions/LinearTransition.d.ts

@@ -0,0 +1,7 @@
+import { ComplexAnimationBuilder } from '../animationBuilder/ComplexAnimationBuilder';
+import { ILayoutAnimationBuilder, LayoutAnimationFunction } from '../animationBuilder/commonTypes';
+export declare class LinearTransition extends ComplexAnimationBuilder implements ILayoutAnimationBuilder {
+    static createInstance(): LinearTransition;
+    build: () => LayoutAnimationFunction;
+}
+export declare const Layout: typeof LinearTransition;

package/lib/types/lib/reanimated2/layoutReanimation/defaultTransitions/SequencedTransition.d.ts

@@ -0,0 +1,9 @@
+import { ILayoutAnimationBuilder, LayoutAnimationFunction } from '../animationBuilder/commonTypes';
+import { BaseAnimationBuilder } from '../animationBuilder';
+export declare class SequencedTransition extends BaseAnimationBuilder implements ILayoutAnimationBuilder {
+    reversed: boolean;
+    static createInstance(): SequencedTransition;
+    static reverse(): SequencedTransition;
+    reverse(): SequencedTransition;
+    build: () => LayoutAnimationFunction;
+}

package/lib/types/lib/reanimated2/layoutReanimation/defaultTransitions/index.d.ts

@@ -0,0 +1,6 @@
+export * from './LinearTransition';
+export * from './FadingTransition';
+export * from './SequencedTransition';
+export * from './JumpingTransition';
+export * from './CurvedTransition';
+export * from './EntryExitTransition';

package/lib/types/lib/reanimated2/layoutReanimation/index.d.ts

@@ -0,0 +1,4 @@
+import './LayoutAnimationRepository';
+export * from './animationBuilder';
+export * from './defaultAnimations';
+export * from './defaultTransitions';

package/lib/types/lib/reanimated2/mock.d.ts

@@ -0,0 +1,55 @@
+declare const NOOP: () => void;
+declare const ID: (t: any) => any;
+declare const IMMEDIATE_CB_INVOCATION: (cb: () => unknown) => unknown;
+declare const ReanimatedV2: {
+    useSharedValue: (v: any) => {
+        value: any;
+    };
+    useDerivedValue: (a: any) => {
+        value: any;
+    };
+    useAnimatedScrollHandler: () => () => void;
+    useAnimatedGestureHandler: () => () => void;
+    useAnimatedStyle: (cb: () => unknown) => unknown;
+    useAnimatedRef: () => {
+        current: null;
+    };
+    useAnimatedReaction: () => void;
+    useAnimatedProps: (cb: () => unknown) => unknown;
+    withTiming: (toValue: any, _: any, cb: any) => any;
+    withSpring: (toValue: any, _: any, cb: any) => any;
+    withDecay: (_: any, cb: any) => number;
+    withDelay: (_: any, animationValue: any) => any;
+    withSequence: (..._animations: any[]) => number;
+    withRepeat: (animation: any) => any;
+    cancelAnimation: () => void;
+    measure: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        pageX: number;
+        pageY: number;
+    };
+    Easing: {
+        linear: (t: any) => any;
+        ease: (t: any) => any;
+        quad: (t: any) => any;
+        cubic: (t: any) => any;
+        poly: (t: any) => any;
+        sin: (t: any) => any;
+        circle: (t: any) => any;
+        exp: (t: any) => any;
+        elastic: (t: any) => any;
+        back: (t: any) => any;
+        bounce: (t: any) => any;
+        bezier: () => {
+            factory: (t: any) => any;
+        };
+        bezierFn: (t: any) => any;
+        in: (t: any) => any;
+        out: (t: any) => any;
+        inOut: (t: any) => any;
+    };
+    runOnJS: (fn: any) => any;
+};

package/lib/types/lib/reanimated2/platform-specific/RNRenderer.d.ts

@@ -0,0 +1 @@
+export { default as RNRenderer } from 'react-native/Libraries/Renderer/shims/ReactNative';

package/lib/types/lib/reanimated2/utils.d.ts

@@ -0,0 +1,7 @@
+import { Component } from 'react';
+import { RefObjectFunction } from './hook/commonTypes';
+export interface ComponentCoords {
+    x: number;
+    y: number;
+}
+export declare function getRelativeCoords(parentRef: RefObjectFunction<Component>, x: number, y: number): ComponentCoords;

package/lib/types/lib/setAndForwardRef.d.ts

@@ -0,0 +1,40 @@
+/**
+ * imported from react-native
+ */
+import { MutableRefObject } from 'react';
+/**
+ * This is a helper function for when a component needs to be able to forward a ref
+ * to a child component, but still needs to have access to that component as part of
+ * its implementation.
+ *
+ * Its main use case is in wrappers for native components.
+ *
+ * Usage:
+ *
+ *   class MyView extends React.Component {
+ *     _nativeRef = null;
+ *
+ *     _setNativeRef = setAndForwardRef({
+ *       getForwardedRef: () => this.props.forwardedRef,
+ *       setLocalRef: ref => {
+ *         this._nativeRef = ref;
+ *       },
+ *     });
+ *
+ *     render() {
+ *       return <View ref={this._setNativeRef} />;
+ *     }
+ *   }
+ *
+ *   const MyViewWithRef = React.forwardRef((props, ref) => (
+ *     <MyView {...props} forwardedRef={ref} />
+ *   ));
+ *
+ *   module.exports = MyViewWithRef;
+ */
+export declare type ForwardedRef<T> = () => MutableRefObject<T> | ((ref: T) => void);
+declare function setAndForwardRef<T>({ getForwardedRef, setLocalRef, }: {
+    getForwardedRef: ForwardedRef<T>;
+    setLocalRef: (ref: T) => void;
+}): (ref: T) => void;
+export default setAndForwardRef;

package/lib/types/react-native-reanimated-tests.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-reanimated",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "More powerful alternative to Animated library for React Native.",
   "scripts": {
     "start": "node node_modules/react-native/local-cli/cli.js start",
@@ -18,10 +18,11 @@
     "format:common": "find Common/ -iname *.h -o -iname *.cpp | xargs clang-format -i",
     "release": "npm login && release-it",
     "type:check": "yarn tsc --noEmit",
-    "type:generate": "yarn type:generate:clean && yarn type:generate:cp-js-src && yarn type:generate:tsc && yarn type:generate:remove.ts && yarn type:generate:remove.tsx && yarn type:generate:remove.js:from-src",
+    "type:generate": "yarn type:generate:clean && yarn type:generate:cp-js-src && yarn type:generate:tsc && yarn type:generate:tsc:declaration && yarn type:generate:remove.ts && yarn type:generate:remove.tsx && yarn type:generate:remove.js:from-src",
     "type:generate:clean": "rm -rf lib/ && mkdir lib/",
     "type:generate:cp-js-src": "cp -RL src/* lib/",
     "type:generate:tsc": "yarn tsc",
+    "type:generate:tsc:declaration": "yarn tsc --project tsconfig.json --pretty --declaration --emitDeclarationOnly --outDir lib/types",
     "type:generate:remove.ts": "find ./lib -type f -name \"*.ts\" -and -not -name \"*.d.ts\" -delete",
     "type:generate:remove.tsx": "find ./lib -type f -name \"*.tsx\" -and -not -name \"*.d.ts\" -delete",
     "type:generate:remove.js:from-src": "find ./src/reanimated2 -type f -name \"*.js\" -delete",
@@ -54,7 +55,6 @@
     "react-native-reanimated.d.ts",
     "mock.js",
     "plugin.js",
-    "expo-module.config.json",
     "!__snapshots__",
     "!*.test.js",
     "!*.test.js.map"
@@ -124,7 +124,7 @@
     "madge": "^5.0.1",
     "prettier": "^2.5.1",
     "react": "17.0.2",
-    "react-native": "0.68.0-rc.2",
+    "react-native": "0.68.0",
     "react-native-codegen": "^0.0.7",
     "react-native-gesture-handler": "^1.6.1",
     "react-test-renderer": "17.0.2",

package/plugin.js

@@ -87,6 +87,7 @@ const blacklistedFunctions = new Set([
   'toString',
   'map',
   'filter',
+  'findIndex',
   'forEach',
   'valueOf',
   'toPrecision',

package/react-native-reanimated.d.ts

@@ -7,8 +7,6 @@ declare module 'react-native-reanimated' {
     ReactNode,
     Component,
     RefObject,
-    ComponentType,
-    ComponentProps,
     FunctionComponent,
   } from 'react';
   import {
@@ -31,7 +29,6 @@ declare module 'react-native-reanimated' {
     NativeScrollEvent,
     NativeSyntheticEvent,
     ColorValue,
-    OpaqueColorValue,
     EasingFunction,
   } from 'react-native';
   import {
@@ -39,24 +36,24 @@ declare module 'react-native-reanimated' {
     PanGestureHandlerGestureEvent,
   } from 'react-native-gesture-handler';
 
-  import('./src/reanimated2/globals');
+  import('./lib/reanimated2/globals');
 
   export type TimingAnimation =
-    import('./src/reanimated2/animation/index').TimingAnimation;
+    import('./lib/types/lib/reanimated2/animation/index').TimingAnimation;
   export type SpringAnimation =
-    import('./src/reanimated2/animation/index').SpringAnimation;
+    import('./lib/types/lib/reanimated2/animation/index').SpringAnimation;
   export type DecayAnimation =
-    import('./src/reanimated2/animation/index').DecayAnimation;
+    import('./lib/types/lib/reanimated2/animation/index').DecayAnimation;
   export type DelayAnimation =
-    import('./src/reanimated2/animation/commonTypes').DelayAnimation;
+    import('./lib/types/lib/reanimated2/animation/commonTypes').DelayAnimation;
   export type RepeatAnimation =
-    import('./src/reanimated2/animation/index').RepeatAnimation;
+    import('./lib/types/lib/reanimated2/animation/index').RepeatAnimation;
   export type SequenceAnimation =
-    import('./src/reanimated2/animation/index').SequenceAnimation;
+    import('./lib/types/lib/reanimated2/animation/index').SequenceAnimation;
   export type StyleLayoutAnimation =
-    import('./src/reanimated2/animation/index').StyleLayoutAnimation;
+    import('./lib/types/lib/reanimated2/animation/index').StyleLayoutAnimation;
   export type Animation<T> =
-    import('./src/reanimated2/commonTypes').Animation<T>;
+    import('./lib/types/lib/reanimated2/commonTypes').Animation<T>;
 
   namespace Animated {
     type Nullable<T> = T | null | undefined;
@@ -402,16 +399,16 @@ declare module 'react-native-reanimated' {
       value: Adaptable<number>,
       config: InterpolationConfig
     ): AnimatedNode<number>;
-    export function interpolateColors(
+    export function interpolateColors<T extends string | number>(
       animationValue: Adaptable<number>,
       {
         inputRange,
         outputColorRange,
       }: {
         inputRange: ReadonlyArray<Adaptable<number>>;
-        outputColorRange: ReadonlyArray<Adaptable<number | string>>;
+        outputColorRange: ReadonlyArray<Adaptable<T>>;
       }
-    ): AnimatedNode<number | string>;
+    ): AnimatedNode<T>;
     export const max: BinaryOperator;
     export const min: BinaryOperator;
 
@@ -602,29 +599,29 @@ declare module 'react-native-reanimated' {
     restDisplacementThreshold?: number;
     velocity?: number;
   }
-  export function withTiming(
-    toValue: AnimatableValue,
+  export function withTiming<T extends AnimatableValue>(
+    toValue: T,
     userConfig?: WithTimingConfig,
     callback?: AnimationCallback
-  ): number;
-  export function withSpring(
-    toValue: AnimatableValue,
+  ): T;
+  export function withSpring<T extends AnimatableValue>(
+    toValue: T,
     userConfig?: WithSpringConfig,
     callback?: AnimationCallback
-  ): number;
+  ): T;
   export function withDecay(
     userConfig: WithDecayConfig,
     callback?: AnimationCallback
   ): number;
   export function cancelAnimation<T>(sharedValue: SharedValue<T>): void;
-  export function withDelay(delayMS: number, delayedAnimation: number): number;
-  export function withRepeat(
-    animation: number,
+  export function withDelay<T extends AnimatableValue>(delayMS: number, delayedAnimation: T): T;
+  export function withRepeat<T extends AnimatableValue>(
+    animation: T,
     numberOfReps?: number,
     reverse?: boolean,
     callback?: AnimationCallback
-  ): number;
-  export function withSequence(...animations: [number, ...number[]]): number;
+  ): T;
+  export function withSequence<T extends AnimatableValue>(...animations: [T, ...T[]]): T;
 
   // reanimated2 functions
   export function runOnUI<A extends any[], R>(
@@ -645,12 +642,12 @@ declare module 'react-native-reanimated' {
     fn: (...args: A) => R
   ): (...args: Parameters<typeof fn>) => R;
 
-  export function interpolateColor(
+  export function interpolateColor<T extends string | number>(
     value: number,
     inputRange: readonly number[],
-    outputRange: readonly (string | number)[],
+    outputRange: readonly T[],
     colorSpace?: 'RGB' | 'HSV'
-  ): string | number;
+  ): T;
 
   export enum ColorSpace {
     RGB = 0,

package/src/createAnimatedComponent.tsx

@@ -161,7 +161,7 @@ interface ComponentRef extends Component {
   getScrollableNode?: () => ComponentRef;
 }
 
-interface InitialComponentProps extends Record<string, unknown> {
+export interface InitialComponentProps extends Record<string, unknown> {
   ref?: Ref<Component>;
   collapsable?: boolean;
 }

package/src/reanimated2/component/FlatList.tsx

@@ -23,7 +23,7 @@ const createCellRenderer = (itemLayoutAnimation?: ILayoutAnimationBuilder) => {
   return cellRenderer;
 };
 
-interface ReanimatedFlatlistProps<ItemT> extends FlatListProps<ItemT> {
+export interface ReanimatedFlatlistProps<ItemT> extends FlatListProps<ItemT> {
   itemLayoutAnimation?: ILayoutAnimationBuilder;
 }
 

package/src/reanimated2/interpolateColor.ts

@@ -58,13 +58,13 @@ const getInterpolateRGB = (
   const a = [];
   for (let i = 0; i < colors.length; ++i) {
     const color = colors[i];
-    const proocessedColor = processColor(color);
+    const processedColor = processColor(color);
     // explicit check in case if processedColor is 0
-    if (proocessedColor !== null && proocessedColor !== undefined) {
-      r.push(red(proocessedColor));
-      g.push(green(proocessedColor));
-      b.push(blue(proocessedColor));
-      a.push(opacity(proocessedColor));
+    if (processedColor !== null && processedColor !== undefined) {
+      r.push(red(processedColor));
+      g.push(green(processedColor));
+      b.push(blue(processedColor));
+      a.push(opacity(processedColor));
     }
   }
   return { r, g, b, a };
@@ -85,11 +85,11 @@ const getInterpolateHSV = (
   const v = [];
   for (let i = 0; i < colors.length; ++i) {
     const color = colors[i];
-    const proocessedColor = RGBtoHSV(processColor(color) as any);
-    if (proocessedColor) {
-      h.push(proocessedColor.h);
-      s.push(proocessedColor.s);
-      v.push(proocessedColor.v);
+    const processedColor = RGBtoHSV(processColor(color) as any);
+    if (processedColor) {
+      h.push(processedColor.h);
+      s.push(processedColor.s);
+      v.push(processedColor.v);
     }
   }
   return { h, s, v };

package/src/reanimated2/jestUtils.ts

@@ -2,6 +2,17 @@
 // @ts-nocheck
 import { jestResetJsReanimatedModule } from './core';
 
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace jest {
+    interface Matchers<R> {
+      toHaveAnimatedStyle(
+        style: Record<string, unknown>[] | Record<string, unknown>
+      ): R;
+    }
+  }
+}
+
 let config = {
   fps: 60,
 };

package/src/reanimated2/js-reanimated/index.ts

@@ -20,7 +20,7 @@ if (shouldBeUseWeb()) {
   };
   global._measure = () => {
     console.warn(
-      "[Reanimated] You can't use 'measue' method with Chrome Debugger or with web version"
+      "[Reanimated] You can't use `measure` with Chrome Debugger or with web version"
     );
     return {
       x: 0,
@@ -33,12 +33,12 @@ if (shouldBeUseWeb()) {
   };
   global._scrollTo = () => {
     console.warn(
-      "[Reanimated] You can't use 'scrollTo' method with Chrome Debugger or with web version"
+      "[Reanimated] You can't use `scrollTo` with Chrome Debugger or with web version"
     );
   };
   global._setGestureState = () => {
     console.warn(
-      "[Reanimated] You can't use 'setGestureState' method with Chrome Debugger or with web version"
+      "[Reanimated] You can't use `setGestureState` with Chrome Debugger or with web version"
     );
   };
 }

package/android/expo/linking.gradle

@@ -1,46 +0,0 @@
-def isExpoLinked = false
-rootProject.getSubprojects().forEach({ project ->
-    if (project.plugins.hasPlugin("com.android.application")) {
-        if (project.configurations.implementation.getDependencies().find { dep -> dep.name == "expo" }) {
-            isExpoLinked = true
-        }
-    }
-})
-
-def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-}
-
-if (isExpoLinked) {
-    apply plugin: 'com.android.library'
-
-    android {
-        // Disable aar bundling to fix the error when running `gradle assembleRelease` over `gradle :app:assembleRelease`
-        // which will throw `Direct local .aar file dependencies are not supported when building an AAR.`
-        tasks.whenTaskAdded { task ->
-            if (['bundleDebugAar', 'bundleReleaseAar'].contains(task.name)) {
-                task.enabled = false
-            }
-        }
-
-        compileSdkVersion safeExtGet('compileSdkVersion', 30)
-
-        sourceSets {
-            main.manifest.srcFile 'src/AndroidManifest.xml'
-            main.java.srcDirs = [ 'expo/src/main/java' ]
-        }
-
-        libraryVariants.all {
-            generateBuildConfigProvider?.get()?.enabled = false
-        }
-    }
-
-    dependencies {
-        implementation 'com.facebook.react:react-native:+'
-        implementation project(':expo-modules-core')
-
-        project.configurations.default.artifacts.each { artifact ->
-            api files(artifact.file)
-        }
-    }
-}

package/android/expo/src/main/java/com/swmansion/reanimated/EXReanimatedAdapter.java

@@ -1,12 +0,0 @@
-package com.swmansion.reanimated;
-
-import com.facebook.react.bridge.JavaScriptContextHolder;
-import com.facebook.react.bridge.ReactApplicationContext;
-
-public class EXReanimatedAdapter {
-  public static void registerJSIModules(ReactApplicationContext reactApplicationContext, JavaScriptContextHolder jsContext) {
-    NodesManager nodesManager =
-      reactApplicationContext.getNativeModule(ReanimatedModule.class).getNodesManager();
-    nodesManager.initWithContext(reactApplicationContext);
-  }
-}

package/android/expo/src/main/java/expo/modules/adapters/reanimated/EXReanimatedPackage.java

@@ -1,26 +0,0 @@
-package expo.modules.adapters.reanimated;
-
-import android.content.Context;
-
-import com.facebook.react.bridge.JavaScriptContextHolder;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.swmansion.reanimated.EXReanimatedAdapter;
-
-import java.util.Collections;
-import java.util.List;
-
-import expo.modules.core.interfaces.Package;
-import expo.modules.core.interfaces.ReactNativeHostHandler;
-
-public class EXReanimatedPackage implements Package {
-  @Override
-  public List<? extends ReactNativeHostHandler> createReactNativeHostHandlers(Context context) {
-    final ReactNativeHostHandler handler = new ReactNativeHostHandler() {
-      @Override
-      public void onRegisterJSIModules(ReactApplicationContext reactApplicationContext, JavaScriptContextHolder jsContext, boolean useDeveloperSupport) {
-        EXReanimatedAdapter.registerJSIModules(reactApplicationContext, jsContext);
-      }
-    };
-    return Collections.singletonList(handler);
-  }
-}

package/expo-module.config.json

@@ -1,3 +0,0 @@
-{
-  "platforms": ["android"]
-}