react-native-reanimated 2.16.0 → 2.17.0

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

@@ -0,0 +1,385 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export class FlipInXUp extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (targetValues) => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [
+                            { perspective: 500 },
+                            { rotateX: '90deg' },
+                            { translateY: -targetValues.targetHeight },
+                        ] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: 500 },
+                            { rotateX: delayFunction(delay, animation('0deg', config)) },
+                            { translateY: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipInXUp();
+    }
+}
+export class FlipInYLeft extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (targetValues) => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [
+                            { perspective: 500 },
+                            { rotateY: '-90deg' },
+                            { translateX: -targetValues.targetWidth },
+                        ] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateY: delayFunction(delay, animation('0deg', config)) },
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipInYLeft();
+    }
+}
+export class FlipInXDown extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (targetValues) => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [
+                            { perspective: 500 },
+                            { rotateX: '-90deg' },
+                            { translateY: targetValues.targetHeight },
+                        ] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateX: delayFunction(delay, animation('0deg', config)) },
+                            { translateY: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipInXDown();
+    }
+}
+export class FlipInYRight extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (targetValues) => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [
+                            { perspective: 500 },
+                            { rotateY: '90deg' },
+                            { translateX: targetValues.targetWidth },
+                        ] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateY: delayFunction(delay, animation('0deg', config)) },
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipInYRight();
+    }
+}
+export class FlipInEasyX extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return () => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [{ perspective: 500 }, { rotateX: '90deg' }] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateX: delayFunction(delay, animation('0deg', config)) },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipInEasyX();
+    }
+}
+export class FlipInEasyY extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return () => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [{ perspective: 500 }, { rotateY: '90deg' }] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateY: delayFunction(delay, animation('0deg', config)) },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipInEasyY();
+    }
+}
+export class FlipOutXUp extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (targetValues) => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [
+                            { perspective: 500 },
+                            { rotateX: '0deg' },
+                            { translateY: 0 },
+                        ] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateX: delayFunction(delay, animation('90deg', config)) },
+                            {
+                                translateY: delayFunction(delay, animation(-targetValues.currentHeight, config)),
+                            },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipOutXUp();
+    }
+}
+export class FlipOutYLeft extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (targetValues) => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [
+                            { perspective: 500 },
+                            { rotateY: '0deg' },
+                            { translateX: 0 },
+                        ] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateY: delayFunction(delay, animation('-90deg', config)) },
+                            {
+                                translateX: delayFunction(delay, animation(-targetValues.currentWidth, config)),
+                            },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipOutYLeft();
+    }
+}
+export class FlipOutXDown extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (targetValues) => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [
+                            { perspective: 500 },
+                            { rotateX: '0deg' },
+                            { translateY: 0 },
+                        ] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateX: delayFunction(delay, animation('-90deg', config)) },
+                            {
+                                translateY: delayFunction(delay, animation(targetValues.currentHeight, config)),
+                            },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipOutXDown();
+    }
+}
+export class FlipOutYRight extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (targetValues) => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [
+                            { perspective: 500 },
+                            { rotateY: '0deg' },
+                            { translateX: 0 },
+                        ] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateY: delayFunction(delay, animation('90deg', config)) },
+                            {
+                                translateX: delayFunction(delay, animation(targetValues.currentWidth, config)),
+                            },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipOutYRight();
+    }
+}
+export class FlipOutEasyX extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return () => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [{ perspective: 500 }, { rotateX: '0deg' }] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateX: delayFunction(delay, animation('90deg', config)) },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipOutEasyX();
+    }
+}
+export class FlipOutEasyY extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return () => {
+                'worklet';
+                return {
+                    initialValues: Object.assign({ transform: [{ perspective: 500 }, { rotateY: '0deg' }] }, initialValues),
+                    animations: {
+                        transform: [
+                            { perspective: delayFunction(delay, animation(500, config)) },
+                            { rotateY: delayFunction(delay, animation('90deg', config)) },
+                        ],
+                    },
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new FlipOutEasyY();
+    }
+}

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

@@ -0,0 +1,136 @@
+import { withSequence, withTiming } from '../../animation';
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export class LightSpeedInRight extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, withTiming(1, { duration: duration })),
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, animation(0, Object.assign(Object.assign({}, config), { duration: duration * 0.7 }))),
+                            },
+                            {
+                                skewX: delayFunction(delay, withSequence(withTiming('10deg', { duration: duration * 0.7 }), withTiming('-5deg', { duration: duration * 0.15 }), withTiming('0deg', { duration: duration * 0.15 }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [{ translateX: values.windowWidth }, { skewX: '-45deg' }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new LightSpeedInRight();
+    }
+}
+export class LightSpeedInLeft extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const duration = this.getDuration();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, withTiming(1, { duration: duration })),
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, animation(0, Object.assign(Object.assign({}, config), { duration: duration * 0.7 }))),
+                            },
+                            {
+                                skewX: delayFunction(delay, withSequence(withTiming('-10deg', { duration: duration * 0.7 }), withTiming('5deg', { duration: duration * 0.15 }), withTiming('0deg', { duration: duration * 0.15 }))),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [{ translateX: -values.windowWidth }, { skewX: '45deg' }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new LightSpeedInLeft();
+    }
+}
+export class LightSpeedOutRight extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(0, config)),
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, animation(values.windowWidth, config)),
+                            },
+                            {
+                                skewX: delayFunction(delay, animation('-45deg', config)),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ translateX: 0 }, { skewX: '0deg' }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new LightSpeedOutRight();
+    }
+}
+export class LightSpeedOutLeft extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (values) => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(0, config)),
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, animation(-values.windowWidth, config)),
+                            },
+                            {
+                                skewX: delayFunction(delay, animation('45deg', config)),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ translateX: 0 }, { skewX: '0deg' }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new LightSpeedOutLeft();
+    }
+}

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

@@ -0,0 +1,81 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export class PinwheelIn extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (_values) => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(1, config)),
+                        transform: [
+                            {
+                                scale: delayFunction(delay, animation(1, config)),
+                            },
+                            {
+                                rotate: delayFunction(delay, animation('0', config)),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [
+                            {
+                                scale: 0,
+                            },
+                            {
+                                rotate: '5',
+                            },
+                        ] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new PinwheelIn();
+    }
+}
+export class PinwheelOut extends ComplexAnimationBuilder {
+    constructor() {
+        super(...arguments);
+        this.build = () => {
+            const delayFunction = this.getDelayFunction();
+            const [animation, config] = this.getAnimationAndConfig();
+            const delay = this.getDelay();
+            const callback = this.callbackV;
+            const initialValues = this.initialValues;
+            return (_values) => {
+                'worklet';
+                return {
+                    animations: {
+                        opacity: delayFunction(delay, animation(0, config)),
+                        transform: [
+                            {
+                                scale: delayFunction(delay, animation(0, config)),
+                            },
+                            {
+                                rotate: delayFunction(delay, animation('5', config)),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [
+                            {
+                                scale: 1,
+                            },
+                            {
+                                rotate: '0',
+                            },
+                        ] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new PinwheelOut();
+    }
+}