react-native-reanimated 2.16.0 → 2.17.0

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

@@ -0,0 +1,120 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export class RollInLeft 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: {
+                        transform: [
+                            { translateX: delayFunction(delay, animation(0), config) },
+                            { rotate: delayFunction(delay, animation('0deg', config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [
+                            { translateX: -values.windowWidth },
+                            { rotate: '-180deg' },
+                        ] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RollInLeft();
+    }
+}
+export class RollInRight 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: {
+                        transform: [
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                            { rotate: delayFunction(delay, animation('0deg', config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateX: values.windowWidth }, { rotate: '180deg' }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RollInRight();
+    }
+}
+export class RollOutLeft 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: {
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, animation(-values.windowWidth, config)),
+                            },
+                            { rotate: delayFunction(delay, animation('-180deg', config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateX: 0 }, { rotate: '0deg' }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RollOutLeft();
+    }
+}
+export class RollOutRight 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: {
+                        transform: [
+                            {
+                                translateX: delayFunction(delay, animation(values.windowWidth, config)),
+                            },
+                            { rotate: delayFunction(delay, animation('180deg', config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ transform: [{ translateX: 0 }, { rotate: '0deg' }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RollOutRight();
+    }
+}

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

@@ -0,0 +1,273 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export class RotateInDownLeft 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: [
+                            { rotate: delayFunction(delay, animation('0deg', config)) },
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                            { translateY: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [
+                            { rotate: '-90deg' },
+                            { translateX: values.targetWidth / 2 - values.targetHeight / 2 },
+                            { translateY: -(values.targetWidth / 2 - values.targetHeight / 2) },
+                        ] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RotateInDownLeft();
+    }
+}
+export class RotateInDownRight 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: [
+                            { rotate: delayFunction(delay, animation('0deg', config)) },
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                            { translateY: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [
+                            { rotate: '90deg' },
+                            { translateX: -(values.targetWidth / 2 - values.targetHeight / 2) },
+                            { translateY: -(values.targetWidth / 2 - values.targetHeight / 2) },
+                        ] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RotateInDownRight();
+    }
+}
+export class RotateInUpLeft 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: [
+                            { rotate: delayFunction(delay, animation('0deg', config)) },
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                            { translateY: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [
+                            { rotate: '90deg' },
+                            { translateX: values.targetWidth / 2 - values.targetHeight / 2 },
+                            { translateY: values.targetWidth / 2 - values.targetHeight / 2 },
+                        ] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RotateInUpLeft();
+    }
+}
+export class RotateInUpRight 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: [
+                            { rotate: delayFunction(delay, animation('0deg', config)) },
+                            { translateX: delayFunction(delay, animation(0, config)) },
+                            { translateY: delayFunction(delay, animation(0, config)) },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 0, transform: [
+                            { rotate: '-90deg' },
+                            { translateX: -(values.targetWidth / 2 - values.targetHeight / 2) },
+                            { translateY: values.targetWidth / 2 - values.targetHeight / 2 },
+                        ] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RotateInUpRight();
+    }
+}
+export class RotateOutDownLeft 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: [
+                            { rotate: delayFunction(delay, animation('90deg', config)) },
+                            {
+                                translateX: delayFunction(delay, animation(values.currentWidth / 2 - values.currentHeight / 2, config)),
+                            },
+                            {
+                                translateY: delayFunction(delay, animation(values.currentWidth / 2 - values.currentHeight / 2, config)),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ rotate: '0deg' }, { translateX: 0 }, { translateY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RotateOutDownLeft();
+    }
+}
+export class RotateOutDownRight 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: [
+                            { rotate: delayFunction(delay, animation('-90deg', config)) },
+                            {
+                                translateX: delayFunction(delay, animation(-(values.currentWidth / 2 - values.currentHeight / 2), config)),
+                            },
+                            {
+                                translateY: delayFunction(delay, animation(values.currentWidth / 2 - values.currentHeight / 2, config)),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ rotate: '0deg' }, { translateX: 0 }, { translateY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RotateOutDownRight();
+    }
+}
+export class RotateOutUpLeft 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: [
+                            { rotate: delayFunction(delay, animation('-90deg', config)) },
+                            {
+                                translateX: delayFunction(delay, animation(values.currentWidth / 2 - values.currentHeight / 2, config)),
+                            },
+                            {
+                                translateY: delayFunction(delay, animation(-(values.currentWidth / 2 - values.currentHeight / 2), config)),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ rotate: '0deg' }, { translateX: 0 }, { translateY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RotateOutUpLeft();
+    }
+}
+export class RotateOutUpRight 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: [
+                            { rotate: delayFunction(delay, animation('90deg', config)) },
+                            {
+                                translateX: delayFunction(delay, animation(-(values.currentWidth / 2 - values.currentHeight / 2), config)),
+                            },
+                            {
+                                translateY: delayFunction(delay, animation(-(values.currentWidth / 2 - values.currentHeight / 2), config)),
+                            },
+                        ],
+                    },
+                    initialValues: Object.assign({ opacity: 1, transform: [{ rotate: '0deg' }, { translateX: 0 }, { translateY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new RotateOutUpRight();
+    }
+}

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

@@ -0,0 +1,201 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export class SlideInRight 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: {
+                        originX: delayFunction(delay, animation(values.targetOriginX, config)),
+                    },
+                    initialValues: Object.assign({ originX: values.targetOriginX + values.windowWidth }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new SlideInRight();
+    }
+}
+export class SlideInLeft 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: {
+                        originX: delayFunction(delay, animation(values.targetOriginX, config)),
+                    },
+                    initialValues: Object.assign({ originX: values.targetOriginX - values.windowWidth }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new SlideInLeft();
+    }
+}
+export class SlideOutRight 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: {
+                        originX: delayFunction(delay, animation(Math.max(values.currentOriginX + values.windowWidth, values.windowWidth), config)),
+                    },
+                    initialValues: Object.assign({ originX: values.currentOriginX }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new SlideOutRight();
+    }
+}
+export class SlideOutLeft 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: {
+                        originX: delayFunction(delay, animation(Math.min(values.currentOriginX - values.windowWidth, -values.windowWidth), config)),
+                    },
+                    initialValues: Object.assign({ originX: values.currentOriginX }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new SlideOutLeft();
+    }
+}
+export class SlideInUp 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: {
+                        originY: delayFunction(delay, animation(values.targetOriginY, config)),
+                    },
+                    initialValues: Object.assign({ originY: -values.windowHeight }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new SlideInUp();
+    }
+}
+export class SlideInDown 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: {
+                        originY: delayFunction(delay, animation(values.targetOriginY, config)),
+                    },
+                    initialValues: Object.assign({ originY: values.targetOriginY + values.windowHeight }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new SlideInDown();
+    }
+}
+export class SlideOutUp 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: {
+                        originY: delayFunction(delay, animation(Math.min(values.currentOriginY - values.windowHeight, -values.windowHeight), config)),
+                    },
+                    initialValues: Object.assign({ originY: values.currentOriginY }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new SlideOutUp();
+    }
+}
+export class SlideOutDown 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: {
+                        originY: delayFunction(delay, animation(Math.max(values.currentOriginY + values.windowHeight, values.windowHeight), config)),
+                    },
+                    initialValues: Object.assign({ originY: values.currentOriginY }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new SlideOutDown();
+    }
+}

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

@@ -0,0 +1,101 @@
+import { ComplexAnimationBuilder } from '../animationBuilder';
+export class StretchInX 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 {
+                    animations: {
+                        transform: [{ scaleX: delayFunction(delay, animation(1, config)) }],
+                    },
+                    initialValues: Object.assign({ transform: [{ scaleX: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new StretchInX();
+    }
+}
+export class StretchInY 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 {
+                    animations: {
+                        transform: [{ scaleY: delayFunction(delay, animation(1, config)) }],
+                    },
+                    initialValues: Object.assign({ transform: [{ scaleY: 0 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new StretchInY();
+    }
+}
+export class StretchOutX 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 {
+                    animations: {
+                        transform: [{ scaleX: delayFunction(delay, animation(0, config)) }],
+                    },
+                    initialValues: Object.assign({ transform: [{ scaleX: 1 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new StretchOutX();
+    }
+}
+export class StretchOutY 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 {
+                    animations: {
+                        transform: [{ scaleY: delayFunction(delay, animation(0, config)) }],
+                    },
+                    initialValues: Object.assign({ transform: [{ scaleY: 1 }] }, initialValues),
+                    callback: callback,
+                };
+            };
+        };
+    }
+    static createInstance() {
+        return new StretchOutY();
+    }
+}