react-native-reanimated 2.16.0 → 2.17.0

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

@@ -0,0 +1,34 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+import { EntryAnimationsValues, ExitAnimationsValues, AnimationConfigFunction, IEntryAnimationBuilder, IExitAnimationBuilder } from '../animationBuilder/commonTypes';
+export declare class RotateInDownLeft extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): RotateInDownLeft;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class RotateInDownRight extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): RotateInDownRight;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class RotateInUpLeft extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): RotateInUpLeft;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class RotateInUpRight extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): RotateInUpRight;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class RotateOutDownLeft extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): RotateOutDownLeft;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class RotateOutDownRight extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): RotateOutDownRight;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class RotateOutUpLeft extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): RotateOutUpLeft;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class RotateOutUpRight extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): RotateOutUpRight;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}

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

@@ -0,0 +1,34 @@
+import { EntryAnimationsValues, ExitAnimationsValues, AnimationConfigFunction, IEntryAnimationBuilder, IExitAnimationBuilder } from '../animationBuilder/commonTypes';
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export declare class SlideInRight extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): SlideInRight;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class SlideInLeft extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): SlideInLeft;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class SlideOutRight extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): SlideOutRight;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class SlideOutLeft extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): SlideOutLeft;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class SlideInUp extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): SlideInUp;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class SlideInDown extends ComplexAnimationBuilder implements IEntryAnimationBuilder {
+    static createInstance(): SlideInDown;
+    build: () => AnimationConfigFunction<EntryAnimationsValues>;
+}
+export declare class SlideOutUp extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): SlideOutUp;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}
+export declare class SlideOutDown extends ComplexAnimationBuilder implements IExitAnimationBuilder {
+    static createInstance(): SlideOutDown;
+    build: () => AnimationConfigFunction<ExitAnimationsValues>;
+}

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

@@ -0,0 +1,18 @@
+import { IEntryExitAnimationBuilder, EntryExitAnimationFunction } from '../animationBuilder/commonTypes';
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export declare class StretchInX extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): StretchInX;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class StretchInY extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): StretchInY;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class StretchOutX extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): StretchOutX;
+    build: () => EntryExitAnimationFunction;
+}
+export declare class StretchOutY extends ComplexAnimationBuilder implements IEntryExitAnimationBuilder {
+    static createInstance(): StretchOutY;
+    build: () => EntryExitAnimationFunction;
+}

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,61 @@
+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;
+    };
+    Extrapolation: {
+        EXTEND: string;
+        CLAMP: string;
+        IDENTITY: string;
+    };
+    runOnJS: (fn: any) => any;
+    runOnUI: (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/platform-specific/checkVersion.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks that native and js versions of reanimated match.
+ */
+export declare function checkVersion(): void;

package/lib/types/lib/reanimated2/platform-specific/checkVersion.web.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks that native and js versions of reanimated match.
+ * Stubbed for web, where this check is unnecessary.
+ */
+export declare function checkVersion(): void;

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

@@ -0,0 +1,11 @@
+import { Component } from 'react';
+import { RefObjectFunction } from './hook/commonTypes';
+export interface ComponentCoords {
+    x: number;
+    y: number;
+}
+/**
+ * Given an absolute position and a component ref, returns the relative
+ * position in the component's local coordinate space.
+ */
+export declare function getRelativeCoords(parentRef: RefObjectFunction<Component>, absoluteX: number, absoluteY: number): ComponentCoords | null;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-reanimated",
-  "version": "2.16.0",
+  "version": "2.17.0",
   "description": "More powerful alternative to Animated library for React Native.",
   "scripts": {
     "test": "yarn run format:js && yarn run lint:js && yarn run test:unit",

package/src/reanimated1/core/Core.test.js

@@ -1,30 +0,0 @@
-import React from 'react';
-import Animated from '../../Animated';
-
-import renderer from 'react-test-renderer';
-
-jest.mock('../../ReanimatedEventEmitter');
-jest.mock('../../ReanimatedModule');
-jest.mock('../../reanimated2/NativeReanimated/NativeReanimated');
-
-describe('Core Animated components', () => {
-  xit('fails if something other then a node or function that returns a node is passed to Animated.Code exec prop', () => {
-    console.error = jest.fn();
-
-    expect(() =>
-      renderer.create(<Animated.Code exec="not a node" />)
-    ).toThrowError(
-      "<Animated.Code /> expects the 'exec' prop or children to be an animated node or a function returning an animated node."
-    );
-  });
-
-  xit('fails if something other then a node or function that returns a node is passed to Animated.Code children', () => {
-    console.error = jest.fn();
-
-    expect(() =>
-      renderer.create(<Animated.Code>not a node</Animated.Code>)
-    ).toThrowError(
-      "<Animated.Code /> expects the 'exec' prop or children to be an animated node or a function returning an animated node."
-    );
-  });
-});