react-native-reanimated 2.16.0 → 2.17.0

package/lib/reanimated2/layoutReanimation/defaultAnimations/Bounce.js

@@ -0,0 +1,374 @@
+import { withSequence, withTiming } from '../../animation';
+import { ComplexAnimationBuilder } from '../animationBuilder/ComplexAnimationBuilder';
+export class BounceIn extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                scale: delayFunction(delay, withSequence(withTiming(1.2, { duration: duration * 0.55 }), withTiming(0.9, { duration: duration * 0.15 }), withTiming(1.1, { duration: duration * 0.15 }), withTiming(1, { duration: duration * 0.15 }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ scale: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceIn();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceInDown extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                translateY: delayFunction(delay, withSequence(withTiming(-20, { duration: duration * 0.55 }), withTiming(10, { duration: duration * 0.15 }), withTiming(-10, { duration: duration * 0.15 }), withTiming(0, { duration: duration * 0.15 }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [
+                            {
+                                translateY: values.windowHeight,
+                            },
+                        ] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceInDown();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceInUp extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                translateY: delayFunction(delay, withSequence(withTiming(20, { duration: duration * 0.55 }), withTiming(-10, { duration: duration * 0.15 }), withTiming(10, { duration: duration * 0.15 }), withTiming(0, { duration: duration * 0.15 }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateY: -values.windowHeight }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceInUp();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceInLeft extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, withSequence(withTiming(20, { duration: duration * 0.55 }), withTiming(-10, { duration: duration * 0.15 }), withTiming(10, { duration: duration * 0.15 }), withTiming(0, { duration: duration * 0.15 }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateX: -values.windowWidth }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceInLeft();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceInRight extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, withSequence(withTiming(-20, { duration: duration * 0.55 }), withTiming(10, { duration: duration * 0.15 }), withTiming(-10, { duration: duration * 0.15 }), withTiming(0, { duration: duration * 0.15 }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateX: values.windowWidth }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceInRight();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceOut extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                scale: delayFunction(delay, withSequence(withTiming(1.1, { duration: duration * 0.15 }), withTiming(0.9, { duration: duration * 0.15 }), withTiming(1.2, { duration: duration * 0.15 }), withTiming(0, { duration: duration * 0.55 }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ scale: 1 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceOut();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceOutDown extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                translateY: delayFunction(delay, withSequence(withTiming(-10, { duration: duration * 0.15 }), withTiming(10, { duration: duration * 0.15 }), withTiming(-20, { duration: duration * 0.15 }), withTiming(values.windowHeight, {
+                                    duration: duration * 0.55,
+                                }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceOutDown();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceOutUp extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                translateY: delayFunction(delay, withSequence(withTiming(10, { duration: duration * 0.15 }), withTiming(-10, { duration: duration * 0.15 }), withTiming(20, { duration: duration * 0.15 }), withTiming(-values.windowHeight, {
+                                    duration: duration * 0.55,
+                                }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceOutUp();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceOutLeft extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, withSequence(withTiming(10, { duration: duration * 0.15 }), withTiming(-10, { duration: duration * 0.15 }), withTiming(20, { duration: duration * 0.15 }), withTiming(-values.windowWidth, {
+                                    duration: duration * 0.55,
+                                }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateX: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceOutLeft();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}
+export class BounceOutRight extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, withSequence(withTiming(-10, { duration: duration * 0.15 }), withTiming(10, { duration: duration * 0.15 }), withTiming(-20, { duration: duration * 0.15 }), withTiming(values.windowWidth, {
+                                    duration: duration * 0.55,
+                                }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateX: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new BounceOutRight();
+    }
+    static getDuration() {
+        return 600;
+    }
+    getDuration() {
+        var _a;
+        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 600;
+    }
+}

package/lib/reanimated2/layoutReanimation/defaultAnimations/Default.js

@@ -0,0 +1,36 @@
+export const DefaultLayout = (values) => {
+    'worklet';
+    return {
+        initialValues: {
+            originX: values.targetOriginX,
+            originY: values.targetOriginY,
+            width: values.targetWidth,
+            height: values.targetHeight,
+        },
+        animations: {},
+    };
+};
+export const DefaultEntering = (values) => {
+    'worklet';
+    return {
+        initialValues: {
+            originX: values.targetOriginX,
+            originY: values.targetOriginY,
+            width: values.targetWidth,
+            height: values.targetHeight,
+        },
+        animations: {},
+    };
+};
+export const DefaultExiting = (values) => {
+    'worklet';
+    return {
+        initialValues: {
+            originX: values.currentOriginX,
+            originY: values.currentOriginY,
+            width: values.currentWidth,
+            height: values.currentHeight,
+        },
+        animations: {},
+    };
+};

package/lib/reanimated2/layoutReanimation/defaultAnimations/Fade.js

@@ -0,0 +1,275 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export class FadeIn extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return (_) => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(1, config)),
+                    },
+                    initialValues: Object.assign({ opacity: 0 }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeIn();
+    }
+}
+export class FadeInRight extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(1, config)),
+                        transform: [
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [{ translateX: 25 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeInRight();
+    }
+}
+export class FadeInLeft extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(1, config)),
+                        transform: [
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [{ translateX: -25 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeInLeft();
+    }
+}
+export class FadeInUp extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(1, config)),
+                        transform: [
+                            { translateY: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [{ translateY: -25 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeInUp();
+    }
+}
+export class FadeInDown extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(1, config)),
+                        transform: [
+                            { translateY: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [{ translateY: 25 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeInDown();
+    }
+}
+export class FadeOut extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return (_) => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(0, config)),
+                    },
+                    initialValues: Object.assign({ opacity: 1 }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeOut();
+    }
+}
+export class FadeOutRight extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(0, config)),
+                        transform: [
+                            { translateX: delayFunction(delay, animation(25, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ translateX: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeOutRight();
+    }
+}
+export class FadeOutLeft extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(0, config)),
+                        transform: [
+                            { translateX: delayFunction(delay, animation(-25, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ translateX: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeOutLeft();
+    }
+}
+export class FadeOutUp extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(0, config)),
+                        transform: [
+                            { translateY: delayFunction(delay, animation(-25, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ translateY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeOutUp();
+    }
+}
+export class FadeOutDown extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            const delay = this.getDelay();
+            return () => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(0, config)),
+                        transform: [
+                            { translateY: delayFunction(delay, animation(25, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ translateY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FadeOutDown();
+    }
+}