react-native-reanimated 2.5.0 → 2.8.0

package/lib/reanimated2/Easing.js

@@ -53,7 +53,10 @@ function cubic(t) {
  */
 function poly(n) {
     'worklet';
-    return (t) => Math.pow(t, n);
+    return (t) => {
+        'worklet';
+        return Math.pow(t, n);
+    };
 }
 /**
  * A sinusoidal function.
@@ -110,7 +113,10 @@ function elastic(bounciness = 1) {
  */
 function back(s = 1.70158) {
     'worklet';
-    return (t) => t * t * ((s + 1) * t - s);
+    return (t) => {
+        'worklet';
+        return t * t * ((s + 1) * t - s);
+    };
 }
 /**
  * Provides a simple bouncing effect.
@@ -224,7 +230,7 @@ function createChecker(worklet, workletName, prevArgs) {
         }
         // @ts-ignore this is implicitly any - TODO
         const res = worklet.apply(this, arguments);
-        if (!_WORKLET && res && typeof res === 'function' && res.__worklet) {
+        if (!_WORKLET && res && typeof res === 'function' && res.__workletHash) {
             return createChecker(res, workletName, arguments);
         }
         return res;

package/lib/reanimated2/core.js

@@ -2,9 +2,6 @@
 import NativeReanimatedModule from './NativeReanimated';
 import { Platform } from 'react-native';
 import { nativeShouldBeMock, shouldBeUseWeb, isWeb } from './PlatformChecker';
-global.__reanimatedWorkletInit = function (worklet) {
-    worklet.__worklet = true;
-};
 if (global._setGlobalConsole === undefined) {
     // it can happen when Reanimated plugin wasn't added, but the user uses the only API from version 1
     global._setGlobalConsole = () => {
@@ -31,39 +28,6 @@ export const isConfiguredCheck = () => {
         throw new Error('If you want to use Reanimated 2 then go through our installation steps https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation');
     }
 };
-function _toArrayReanimated(object) {
-    'worklet';
-    if (Array.isArray(object)) {
-        return object;
-    }
-    if (typeof Symbol !== 'undefined' &&
-        (typeof Symbol === 'function' ? Symbol.iterator : '@@iterator') in
-            Object(object)) {
-        return Array.from(object);
-    }
-    throw new Error('Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.');
-}
-function _mergeObjectsReanimated() {
-    'worklet';
-    // we can't use rest parameters in worklets at the moment
-    // eslint-disable-next-line prefer-rest-params
-    const arr = Array.from(arguments);
-    return Object.assign.apply(null, [arr[0], ...arr.slice(1)]);
-}
-global.__reanimatedWorkletInit = function (worklet) {
-    worklet.__worklet = true;
-    if (worklet._closure) {
-        const closure = worklet._closure;
-        Object.keys(closure).forEach((key) => {
-            if (key === '_toConsumableArray') {
-                closure[key] = _toArrayReanimated;
-            }
-            if (key === '_objectSpread') {
-                closure[key] = _mergeObjectsReanimated;
-            }
-        });
-    }
-};
 function pushFrame(frame) {
     NativeReanimatedModule.pushFrame(frame);
 }

package/lib/reanimated2/globals.d.ts

@@ -1,4 +1,4 @@
-import { AnimatedStyle, StyleProps, WorkletFunction } from './commonTypes';
+import { AnimatedStyle, StyleProps } from './commonTypes';
 import { ReanimatedConsole } from './core';
 import { MeasuredDimensions } from './NativeMethods';
 import { NativeReanimated } from './NativeReanimated/NativeReanimated';
@@ -32,7 +32,6 @@ declare global {
   };
   namespace NodeJS {
     interface Global {
-      __reanimatedWorkletInit: (worklet: WorkletFunction) => void;
       _setGlobalConsole: (console?: ReanimatedConsole) => void;
       _log: (s: string) => void;
       _setGestureState: () => void;

package/lib/reanimated2/interpolateColor.js

@@ -27,13 +27,13 @@ const getInterpolateRGB = (colors) => {
     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 };
@@ -45,11 +45,11 @@ const getInterpolateHSV = (colors) => {
     const v = [];
     for (let i = 0; i < colors.length; ++i) {
         const color = colors[i];
-        const proocessedColor = RGBtoHSV(processColor(color));
-        if (proocessedColor) {
-            h.push(proocessedColor.h);
-            s.push(proocessedColor.s);
-            v.push(proocessedColor.v);
+        const processedColor = RGBtoHSV(processColor(color));
+        if (processedColor) {
+            h.push(processedColor.h);
+            s.push(processedColor.s);
+            v.push(processedColor.v);
         }
     }
     return { h, s, v };

package/lib/reanimated2/js-reanimated/index.js

@@ -7,7 +7,7 @@ if (shouldBeUseWeb()) {
         // noop
     };
     global._measure = () => {
-        console.warn("[Reanimated] You can't use 'measue' method with Chrome Debugger or with web version");
+        console.warn("[Reanimated] You can't use `measure` with Chrome Debugger or with web version");
         return {
             x: 0,
             y: 0,
@@ -18,10 +18,10 @@ if (shouldBeUseWeb()) {
         };
     };
     global._scrollTo = () => {
-        console.warn("[Reanimated] You can't use 'scrollTo' method with Chrome Debugger or with web version");
+        console.warn("[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");
+        console.warn("[Reanimated] You can't use `setGestureState` with Chrome Debugger or with web version");
     };
 }
 export const _updatePropsJS = (updates, viewRef) => {

package/lib/types/lib/ConfigHelper.d.ts

@@ -0,0 +1,12 @@
+export declare function addWhitelistedNativeProps(props: Record<string, boolean>): void;
+export declare function addWhitelistedUIProps(props: Record<string, boolean>): void;
+interface ViewConfig {
+    uiViewClassName: string;
+    validAttributes: Record<string, unknown>;
+}
+/**
+ * updates UI props whitelist for given view host instance
+ * this will work just once for every view name
+ */
+export declare function adaptViewConfig(viewConfig: ViewConfig): void;
+export {};

package/lib/types/lib/ReanimatedEventEmitter.d.ts

@@ -0,0 +1,3 @@
+import { NativeEventEmitter } from 'react-native';
+declare const _default: NativeEventEmitter;
+export default _default;

package/lib/types/lib/ReanimatedModule.d.ts

@@ -0,0 +1,2 @@
+import ReanimatedModuleCompat from './ReanimatedModuleCompat';
+export default ReanimatedModuleCompat;

package/lib/types/lib/ReanimatedModule.macos.d.ts

@@ -0,0 +1,2 @@
+import ReanimatedModuleCompat from './ReanimatedModuleCompat';
+export default ReanimatedModuleCompat;

package/lib/types/lib/ReanimatedModule.native.d.ts

@@ -0,0 +1,2 @@
+declare let exportedModule: any;
+export default exportedModule;

package/lib/types/lib/ReanimatedModule.windows.d.ts

@@ -0,0 +1,2 @@
+import ReanimatedModuleCompat from './ReanimatedModuleCompat';
+export default ReanimatedModuleCompat;

package/lib/types/lib/ReanimatedModuleCompat.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    disconnectNodeFromView(): Promise<void>;
+    attachEvent(_viewTag: number, _eventName: string, _nodeID: number): Promise<void>;
+    detachEvent(_viewTag: number, _eventName: string, _nodeID: number): Promise<void>;
+    createNode(_nodeID: number, _config: Record<string, unknown>): Promise<void>;
+    dropNode(_nodeID: number): Promise<void>;
+    configureProps(_nativeProps: string[], _uiProps: string[]): Promise<void>;
+    disconnectNodes(): Promise<void>;
+    addListener(): Promise<void>;
+    removeListeners(): Promise<void>;
+    removeAllListeners(): Promise<void>;
+    animateNextTransition(): Promise<void>;
+};
+export default _default;

package/lib/types/lib/createAnimatedComponent.d.ts

@@ -0,0 +1,33 @@
+import { Component, ComponentType, Ref } from 'react';
+import './reanimated2/layoutReanimation/LayoutAnimationRepository';
+import { BaseAnimationBuilder, EntryExitAnimationFunction, ILayoutAnimationBuilder } from './reanimated2/layoutReanimation';
+import { SharedValue, StyleProps } from './reanimated2/commonTypes';
+import { ViewDescriptorsSet, ViewRefSet } from './reanimated2/ViewDescriptorsSet';
+declare type NestedArray<T> = T | NestedArray<T>[];
+interface AnimatedProps extends Record<string, unknown> {
+    viewDescriptors?: ViewDescriptorsSet;
+    viewsRef?: ViewRefSet<unknown>;
+    initial?: SharedValue<StyleProps>;
+}
+export declare type AnimatedComponentProps<P extends Record<string, unknown>> = P & {
+    forwardedRef?: Ref<Component>;
+    style?: NestedArray<StyleProps>;
+    animatedProps?: Partial<AnimatedComponentProps<AnimatedProps>>;
+    animatedStyle?: StyleProps;
+    layout?: BaseAnimationBuilder | ILayoutAnimationBuilder | typeof BaseAnimationBuilder;
+    entering?: BaseAnimationBuilder | typeof BaseAnimationBuilder | EntryExitAnimationFunction | Keyframe;
+    exiting?: BaseAnimationBuilder | typeof BaseAnimationBuilder | EntryExitAnimationFunction | Keyframe;
+};
+declare type Options<P> = {
+    setNativeProps: (ref: ComponentRef, props: P) => void;
+};
+interface ComponentRef extends Component {
+    setNativeProps?: (props: Record<string, unknown>) => void;
+    getScrollableNode?: () => ComponentRef;
+}
+export interface InitialComponentProps extends Record<string, unknown> {
+    ref?: Ref<Component>;
+    collapsable?: boolean;
+}
+export default function createAnimatedComponent(Component: ComponentType<InitialComponentProps>, options?: Options<InitialComponentProps>): ComponentType<AnimatedComponentProps<InitialComponentProps>>;
+export {};

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

@@ -0,0 +1,6 @@
+/**
+ * https://github.com/gre/bezier-easing
+ * BezierEasing - use bezier curve for transition easing function
+ * by Gaëtan Renaudeau 2014 - 2015 – MIT License
+ */
+export declare function Bezier(mX1: number, mY1: number, mX2: number, mY2: number): (x: number) => number;

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

@@ -0,0 +1,31 @@
+/**
+ * Copied from:
+ * react-native/Libraries/StyleSheet/normalizeColor.js
+ * react-native/Libraries/StyleSheet/processColor.js
+ * https://github.com/wcandillon/react-native-redash/blob/master/src/Colors.ts
+ */
+interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+interface HSV {
+    h: number;
+    s: number;
+    v: number;
+}
+export declare const opacity: (c: number) => number;
+export declare const red: (c: number) => number;
+export declare const green: (c: number) => number;
+export declare const blue: (c: number) => number;
+export declare const rgbaColor: (r: number, g: number, b: number, alpha?: number) => number | string;
+export declare function RGBtoHSV(rgb: RGB): HSV;
+export declare function RGBtoHSV(r: number, g: number, b: number): HSV;
+export declare const hsvToColor: (h: number, s: number, v: number) => number | string;
+export declare function processColorInitially(color: unknown): number | null | undefined;
+export declare function isColor(value: unknown): boolean;
+export declare function processColor(color: unknown): number | null | undefined;
+export declare type ParsedColorArray = [number, number, number, number];
+export declare function convertToHSVA(color: unknown): ParsedColorArray;
+export declare function toRGBA(HSVA: ParsedColorArray): string;
+export {};

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

@@ -0,0 +1,172 @@
+/**
+ * The `Easing` module implements common easing functions. This module is used
+ * by [Animate.timing()](docs/animate.html#timing) to convey physically
+ * believable motion in animations.
+ *
+ * You can find a visualization of some common easing functions at
+ * http://easings.net/
+ *
+ * ### Predefined animations
+ *
+ * The `Easing` module provides several predefined animations through the
+ * following methods:
+ *
+ * - [`back`](docs/easing.html#back) provides a simple animation where the
+ *   object goes slightly back before moving forward
+ * - [`bounce`](docs/easing.html#bounce) provides a bouncing animation
+ * - [`ease`](docs/easing.html#ease) provides a simple inertial animation
+ * - [`elastic`](docs/easing.html#elastic) provides a simple spring interaction
+ *
+ * ### Standard functions
+ *
+ * Three standard easing functions are provided:
+ *
+ * - [`linear`](docs/easing.html#linear)
+ * - [`quad`](docs/easing.html#quad)
+ * - [`cubic`](docs/easing.html#cubic)
+ *
+ * The [`poly`](docs/easing.html#poly) function can be used to implement
+ * quartic, quintic, and other higher power functions.
+ *
+ * ### Additional functions
+ *
+ * Additional mathematical functions are provided by the following methods:
+ *
+ * - [`bezier`](docs/easing.html#bezier) provides a cubic bezier curve
+ * - [`circle`](docs/easing.html#circle) provides a circular function
+ * - [`sin`](docs/easing.html#sin) provides a sinusoidal function
+ * - [`exp`](docs/easing.html#exp) provides an exponential function
+ *
+ * The following helpers are used to modify other easing functions.
+ *
+ * - [`in`](docs/easing.html#in) runs an easing function forwards
+ * - [`inOut`](docs/easing.html#inout) makes any easing function symmetrical
+ * - [`out`](docs/easing.html#out) runs an easing function backwards
+ */
+export declare type EasingFn = (t: number) => number;
+export declare type EasingFactoryFn = {
+    factory: () => EasingFn;
+};
+/**
+ * A linear function, `f(t) = t`. Position correlates to elapsed time one to
+ * one.
+ *
+ * http://cubic-bezier.com/#0,0,1,1
+ */
+declare function linear(t: number): number;
+/**
+ * A simple inertial interaction, similar to an object slowly accelerating to
+ * speed.
+ *
+ * http://cubic-bezier.com/#.42,0,1,1
+ */
+declare function ease(t: number): number;
+/**
+ * A quadratic function, `f(t) = t * t`. Position equals the square of elapsed
+ * time.
+ *
+ * http://easings.net/#easeInQuad
+ */
+declare function quad(t: number): number;
+/**
+ * A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed
+ * time.
+ *
+ * http://easings.net/#easeInCubic
+ */
+declare function cubic(t: number): number;
+/**
+ * A power function. Position is equal to the Nth power of elapsed time.
+ *
+ * n = 4: http://easings.net/#easeInQuart
+ * n = 5: http://easings.net/#easeInQuint
+ */
+declare function poly(n: number): EasingFn;
+/**
+ * A sinusoidal function.
+ *
+ * http://easings.net/#easeInSine
+ */
+declare function sin(t: number): number;
+/**
+ * A circular function.
+ *
+ * http://easings.net/#easeInCirc
+ */
+declare function circle(t: number): number;
+/**
+ * An exponential function.
+ *
+ * http://easings.net/#easeInExpo
+ */
+declare function exp(t: number): number;
+/**
+ * A simple elastic interaction, similar to a spring oscillating back and
+ * forth.
+ *
+ * Default bounciness is 1, which overshoots a little bit once. 0 bounciness
+ * doesn't overshoot at all, and bounciness of N > 1 will overshoot about N
+ * times.
+ *
+ * http://easings.net/#easeInElastic
+ */
+declare function elastic(bounciness?: number): EasingFn;
+/**
+ * Use with `Animated.parallel()` to create a simple effect where the object
+ * animates back slightly as the animation starts.
+ *
+ * Wolfram Plot:
+ *
+ * - http://tiny.cc/back_default (s = 1.70158, default)
+ */
+declare function back(s?: number): (t: number) => number;
+/**
+ * Provides a simple bouncing effect.
+ *
+ * http://easings.net/#easeInBounce
+ */
+declare function bounce(t: number): number;
+/**
+ * Provides a cubic bezier curve, equivalent to CSS Transitions'
+ * `transition-timing-function`.
+ *
+ * A useful tool to visualize cubic bezier curves can be found at
+ * http://cubic-bezier.com/
+ */
+declare function bezier(x1: number, y1: number, x2: number, y2: number): {
+    factory: () => (x: number) => number;
+};
+declare function bezierFn(x1: number, y1: number, x2: number, y2: number): (x: number) => number;
+/**
+ * Runs an easing function forwards.
+ */
+declare function in_(easing: EasingFn): EasingFn;
+/**
+ * Runs an easing function backwards.
+ */
+declare function out(easing: EasingFn): EasingFn;
+/**
+ * Makes any easing function symmetrical. The easing function will run
+ * forwards for half of the duration, then backwards for the rest of the
+ * duration.
+ */
+declare function inOut(easing: EasingFn): EasingFn;
+export declare const Easing: {
+    linear: typeof linear;
+    ease: typeof ease;
+    quad: typeof quad;
+    cubic: typeof cubic;
+    poly: typeof poly;
+    sin: typeof sin;
+    circle: typeof circle;
+    exp: typeof exp;
+    elastic: typeof elastic;
+    back: typeof back;
+    bounce: typeof bounce;
+    bezier: typeof bezier;
+    bezierFn: typeof bezierFn;
+    in: typeof in_;
+    out: typeof out;
+    inOut: typeof inOut;
+};
+export {};

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

@@ -0,0 +1,14 @@
+import { Component } from 'react';
+import { RefObjectFunction } from './commonTypes';
+export declare function getTag(view: null | number | React.Component<any, any> | React.ComponentClass<any>): null | number;
+export interface MeasuredDimensions {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pageX: number;
+    pageY: number;
+}
+export declare function measure(animatedRef: RefObjectFunction<Component>): MeasuredDimensions;
+export declare function scrollTo(animatedRef: RefObjectFunction<Component>, x: number, y: number, animated: boolean): void;
+export declare function setGestureState(handlerTag: number, newState: number): void;

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

@@ -0,0 +1,20 @@
+import { SharedValue, SensorValue3D, SensorValueRotation } from '../commonTypes';
+import { Descriptor } from '../hook/commonTypes';
+export declare class NativeReanimated {
+    native: boolean;
+    private InnerNativeModule;
+    constructor(native?: boolean);
+    installCoreFunctions(valueSetter: <T>(value: T) => void): void;
+    makeShareable<T>(value: T): T;
+    makeMutable<T>(value: T): SharedValue<T>;
+    makeRemote<T>(object?: {}): T;
+    registerSensor(sensorType: number, interval: number, sensorData: SensorValue3D | SensorValueRotation): any;
+    unregisterSensor(sensorId: number): any;
+    startMapper(mapper: () => void, inputs: any[] | undefined, outputs: any[] | undefined, updater: () => void, viewDescriptors: Descriptor[] | SharedValue<Descriptor[]>): number;
+    stopMapper(mapperId: number): void;
+    registerEventHandler<T>(eventHash: string, eventHandler: (event: T) => void): string;
+    unregisterEventHandler(id: string): void;
+    getViewProp<T>(viewTag: string, propName: string, callback?: (result: T) => void): Promise<T>;
+    enableLayoutAnimations(flag: boolean): void;
+    configureProps(uiProps: string[], nativeProps: string[]): void;
+}

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

@@ -0,0 +1,3 @@
+import { NativeReanimated } from './NativeReanimated';
+declare const _default: NativeReanimated;
+export default _default;

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

@@ -0,0 +1,5 @@
+export declare function isJest(): boolean;
+export declare function isChromeDebugger(): boolean;
+export declare function isWeb(): boolean;
+export declare function shouldBeUseWeb(): boolean;
+export declare function nativeShouldBeMock(): boolean;

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

@@ -0,0 +1,4 @@
+import { AdapterWorkletFunction } from './commonTypes';
+export declare function createAnimatedPropAdapter(adapter: AdapterWorkletFunction, nativeProps?: string[]): AdapterWorkletFunction;
+export declare const SVGAdapter: AdapterWorkletFunction;
+export declare const TextInputAdapter: AdapterWorkletFunction;

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

@@ -0,0 +1,9 @@
+import { MutableRefObject } from 'react';
+import { AnimatedStyle, SharedValue, StyleProps } from './commonTypes';
+import { Descriptor } from './hook/commonTypes';
+import { ViewRefSet } from './ViewDescriptorsSet';
+export declare const colorProps: string[];
+export declare const ColorProperties: string[];
+export declare const updateProps: (viewDescriptor: SharedValue<Descriptor[]>, updates: StyleProps | AnimatedStyle, maybeViewRef: ViewRefSet<any> | undefined) => void;
+export declare const updatePropsJestWrapper: (viewDescriptors: SharedValue<Descriptor[]>, updates: AnimatedStyle, maybeViewRef: ViewRefSet<any> | undefined, animatedStyle: MutableRefObject<AnimatedStyle>, adapters: ((updates: AnimatedStyle) => void)[]) => void;
+export default updateProps;

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

@@ -0,0 +1,20 @@
+import { SharedValue } from './commonTypes';
+import { Descriptor } from './hook/commonTypes';
+export interface ViewRefSet<T> {
+    items: Set<T>;
+    add: (item: T) => void;
+    remove: (item: T) => void;
+}
+export interface ViewDescriptorsSet {
+    batchToRemove: Set<number>;
+    tags: Set<number>;
+    waitForInsertSync: boolean;
+    waitForRemoveSync: boolean;
+    sharableViewDescriptors: SharedValue<Descriptor[]>;
+    items: Descriptor[];
+    add: (item: Descriptor) => void;
+    remove: (viewTag: number) => void;
+    rebuildsharableViewDescriptors: (sharableViewDescriptor: SharedValue<Descriptor[]>) => void;
+}
+export declare function makeViewDescriptorsSet(): ViewDescriptorsSet;
+export declare function makeViewsRefSet<T>(): ViewRefSet<T>;

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

@@ -0,0 +1,13 @@
+import { NativeEvent } from './commonTypes';
+export default class WorkletEventHandler<T extends NativeEvent<T>> {
+    worklet: (event: T) => void;
+    eventNames: string[];
+    reattachNeeded: boolean;
+    listeners: Record<string, (event: T) => void>;
+    viewTag: number | undefined;
+    registrations: string[];
+    constructor(worklet: (event: T) => void, eventNames?: string[]);
+    updateWorklet(newWorklet: (event: T) => void): void;
+    registerForEvents(viewTag: number, fallbackEventName?: string): void;
+    unregisterFromEvents(): void;
+}

package/lib/types/lib/reanimated2/__mocks__/MutableValue.d.ts

@@ -0,0 +1,5 @@
+export default class MutableValue {
+    constructor(value: any);
+    get value(): any;
+    set value(nextValue: any);
+}

package/lib/types/lib/reanimated2/__mocks__/NativeReanimated.d.ts

@@ -0,0 +1,13 @@
+import MutableValue from './MutableValue';
+declare const _default: {
+    installCoreFunctions: () => void;
+    makeShareable: (worklet: any) => any;
+    makeMutable: (init: any) => MutableValue;
+    makeRemote: () => void;
+    startMapper: () => void;
+    stopMapper: () => void;
+    registerEventHandler: () => void;
+    unregisterEventHandler: () => void;
+    getViewProp: () => void;
+};
+export default _default;

package/lib/types/lib/reanimated2/__mocks__/NativeReanimated.native.d.ts

@@ -0,0 +1,13 @@
+import MutableValue from './MutableValue';
+declare const _default: {
+    installCoreFunctions: () => void;
+    makeShareable: (worklet: any) => any;
+    makeMutable: (init: any) => MutableValue;
+    makeRemote: () => void;
+    startMapper: () => void;
+    stopMapper: () => void;
+    registerEventHandler: () => void;
+    unregisterEventHandler: () => void;
+    getViewProp: () => void;
+};
+export default _default;

package/lib/types/lib/reanimated2/animation/commonTypes.d.ts

@@ -0,0 +1,27 @@
+import { AnimatedStyle, StyleProps, AnimatableValue, AnimationObject, Animation, Timestamp, AnimationCallback } from '../commonTypes';
+export interface HigherOrderAnimation {
+    isHigherOrder?: boolean;
+}
+export declare type NextAnimation<T extends AnimationObject> = T | (() => T);
+export interface DelayAnimation extends Animation<DelayAnimation>, HigherOrderAnimation {
+    startTime: Timestamp;
+    started: boolean;
+    previousAnimation: DelayAnimation | null;
+    current: AnimatableValue;
+}
+export interface RepeatAnimation extends Animation<RepeatAnimation>, HigherOrderAnimation {
+    reps: number;
+    startValue: AnimatableValue;
+    toValue?: AnimatableValue;
+    previousAnimation?: RepeatAnimation;
+}
+export interface SequenceAnimation extends Animation<SequenceAnimation>, HigherOrderAnimation {
+    animationIndex: number;
+}
+export interface StyleLayoutAnimation extends HigherOrderAnimation {
+    current: StyleProps;
+    styleAnimations: AnimatedStyle;
+    onFrame: (animation: StyleLayoutAnimation, timestamp: Timestamp) => boolean;
+    onStart: (nextAnimation: StyleLayoutAnimation, current: AnimatedStyle, timestamp: Timestamp, previousAnimation: StyleLayoutAnimation) => void;
+    callback?: AnimationCallback;
+}

package/lib/types/lib/reanimated2/animation/decay.d.ts

@@ -0,0 +1,19 @@
+import { Animation, AnimationCallback, AnimationObject, AnimatableValue, Timestamp } from '../commonTypes';
+interface DecayConfig {
+    deceleration?: number;
+    velocityFactor?: number;
+    clamp?: number[];
+    velocity?: number;
+}
+export interface DecayAnimation extends Animation<DecayAnimation> {
+    lastTimestamp: Timestamp;
+    startTimestamp: Timestamp;
+    initialVelocity: number;
+    velocity: number;
+    current: AnimatableValue;
+}
+export interface InnerDecayAnimation extends Omit<DecayAnimation, 'current'>, AnimationObject {
+    current: number;
+}
+export declare function withDecay(userConfig: DecayConfig, callback?: AnimationCallback): Animation<DecayAnimation>;
+export {};

package/lib/types/lib/reanimated2/animation/delay.d.ts

@@ -0,0 +1,7 @@
+import { Animation } from '../commonTypes';
+import { NextAnimation, DelayAnimation } from './commonTypes';
+export declare function withDelay(delayMs: number, _nextAnimation: NextAnimation<DelayAnimation>): Animation<DelayAnimation>;
+/**
+ * @deprecated Kept for backward compatibility. Will be removed soon.
+ */
+export declare function delay(delayMs: number, _nextAnimation: NextAnimation<DelayAnimation>): Animation<DelayAnimation>;