react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/lib/reanimated2/animation/decay.js

@@ -1,71 +0,0 @@
-import { defineAnimation } from './util';
-import { Platform } from 'react-native';
-export function withDecay(userConfig, callback) {
-    'worklet';
-    return defineAnimation(0, () => {
-        'worklet';
-        var _a;
-        const config = {
-            deceleration: 0.998,
-            velocityFactor: Platform.OS !== 'web' ? 1 : 1000,
-            velocity: 0,
-        };
-        if (userConfig) {
-            Object.keys(userConfig).forEach((key) => (config[key] = userConfig[key]));
-        }
-        const VELOCITY_EPS = Platform.OS !== 'web' ? 1 : 1 / 20;
-        const SLOPE_FACTOR = 0.1;
-        function decay(animation, now) {
-            const { lastTimestamp, startTimestamp, initialVelocity, current, velocity, } = animation;
-            const deltaTime = Math.min(now - lastTimestamp, 64);
-            const v = velocity *
-                Math.exp(-(1 - config.deceleration) * (now - startTimestamp) * SLOPE_FACTOR);
-            animation.current =
-                current + (v * config.velocityFactor * deltaTime) / 1000; // /1000 because time is in ms not in s
-            animation.velocity = v;
-            animation.lastTimestamp = now;
-            if (config.clamp) {
-                if (initialVelocity < 0 && animation.current <= config.clamp[0]) {
-                    animation.current = config.clamp[0];
-                    return true;
-                }
-                else if (initialVelocity > 0 &&
-                    animation.current >= config.clamp[1]) {
-                    animation.current = config.clamp[1];
-                    return true;
-                }
-            }
-            return Math.abs(v) < VELOCITY_EPS;
-        }
-        function validateConfig() {
-            if (config.clamp) {
-                if (!Array.isArray(config.clamp)) {
-                    throw Error(`config.clamp must be an array but is ${typeof config.clamp}`);
-                }
-                if (config.clamp.length !== 2) {
-                    throw Error(`clamp array must contain 2 items but is given ${config.clamp.length}`);
-                }
-            }
-            if (config.velocityFactor <= 0) {
-                throw Error(`config.velocityFactor must be greather then 0 but is ${config.velocityFactor}`);
-            }
-        }
-        function onStart(animation, value, now) {
-            animation.current = value;
-            animation.lastTimestamp = now;
-            animation.startTimestamp = now;
-            animation.initialVelocity = config.velocity;
-            validateConfig();
-        }
-        return {
-            onFrame: decay,
-            onStart,
-            callback,
-            velocity: (_a = config.velocity) !== null && _a !== void 0 ? _a : 0,
-            initialVelocity: 0,
-            current: 0,
-            lastTimestamp: 0,
-            startTimestamp: 0,
-        };
-    });
-}

package/lib/reanimated2/animation/delay.js

@@ -1,64 +0,0 @@
-import { defineAnimation } from './util';
-export function withDelay(delayMs, _nextAnimation) {
-    'worklet';
-    return defineAnimation(_nextAnimation, () => {
-        'worklet';
-        const nextAnimation = typeof _nextAnimation === 'function' ? _nextAnimation() : _nextAnimation;
-        function delay(animation, now) {
-            const { startTime, started, previousAnimation } = animation;
-            if (now - startTime > delayMs) {
-                if (!started) {
-                    nextAnimation.onStart(nextAnimation, animation.current, now, previousAnimation);
-                    animation.previousAnimation = null;
-                    animation.started = true;
-                }
-                const finished = nextAnimation.onFrame(nextAnimation, now);
-                animation.current = nextAnimation.current;
-                return finished;
-            }
-            else if (previousAnimation) {
-                const finished = previousAnimation.finished ||
-                    previousAnimation.onFrame(previousAnimation, now);
-                animation.current = previousAnimation.current;
-                if (finished) {
-                    animation.previousAnimation = null;
-                }
-            }
-            return false;
-        }
-        function onStart(animation, value, now, previousAnimation) {
-            animation.startTime = now;
-            animation.started = false;
-            animation.current = value;
-            if (previousAnimation === animation) {
-                animation.previousAnimation = previousAnimation.previousAnimation;
-            }
-            else {
-                animation.previousAnimation = previousAnimation;
-            }
-        }
-        const callback = (finished) => {
-            if (nextAnimation.callback) {
-                nextAnimation.callback(finished);
-            }
-        };
-        return {
-            isHigherOrder: true,
-            onFrame: delay,
-            onStart,
-            current: nextAnimation.current,
-            callback,
-            previousAnimation: null,
-            startTime: 0,
-            started: false,
-        };
-    });
-}
-/**
- * @deprecated Kept for backward compatibility. Will be removed soon.
- */
-export function delay(delayMs, _nextAnimation) {
-    'worklet';
-    console.warn('Method `delay` is deprecated. Please use `withDelay` instead');
-    return withDelay(delayMs, _nextAnimation);
-}

package/lib/reanimated2/animation/index.js

@@ -1,8 +0,0 @@
-export { cancelAnimation, defineAnimation, initialUpdaterRun } from './util';
-export { withTiming } from './timing';
-export { withSpring } from './spring';
-export { withDecay } from './decay';
-export { withDelay } from './delay';
-export { withRepeat } from './repeat';
-export { withSequence } from './sequence';
-export { withStyleAnimation } from './styleAnimation';

package/lib/reanimated2/animation/repeat.js

@@ -1,69 +0,0 @@
-import { defineAnimation } from './util';
-export function withRepeat(_nextAnimation, numberOfReps = 2, reverse = false, callback) {
-    'worklet';
-    return defineAnimation(_nextAnimation, () => {
-        'worklet';
-        const nextAnimation = typeof _nextAnimation === 'function' ? _nextAnimation() : _nextAnimation;
-        function repeat(animation, now) {
-            const finished = nextAnimation.onFrame(nextAnimation, now);
-            animation.current = nextAnimation.current;
-            if (finished) {
-                animation.reps += 1;
-                // call inner animation's callback on every repetition
-                // as the second argument the animation's current value is passed
-                if (nextAnimation.callback) {
-                    nextAnimation.callback(true /* finished */, animation.current);
-                }
-                if (numberOfReps > 0 && animation.reps >= numberOfReps) {
-                    return true;
-                }
-                const startValue = reverse
-                    ? nextAnimation.current
-                    : animation.startValue;
-                if (reverse) {
-                    nextAnimation.toValue = animation.startValue;
-                    animation.startValue = startValue;
-                }
-                nextAnimation.onStart(nextAnimation, startValue, now, nextAnimation.previousAnimation);
-                return false;
-            }
-            return false;
-        }
-        const repCallback = (finished) => {
-            if (callback) {
-                callback(finished);
-            }
-            // when cancelled call inner animation's callback
-            if (!finished && nextAnimation.callback) {
-                nextAnimation.callback(false /* finished */);
-            }
-        };
-        function onStart(animation, value, now, previousAnimation) {
-            animation.startValue = value;
-            animation.reps = 0;
-            nextAnimation.onStart(nextAnimation, value, now, previousAnimation);
-        }
-        return {
-            isHigherOrder: true,
-            onFrame: repeat,
-            onStart,
-            reps: 0,
-            current: nextAnimation.current,
-            callback: repCallback,
-            startValue: 0,
-        };
-    });
-}
-/**
- * @deprecated Kept for backward compatibility. Will be removed soon.
- */
-export function repeat(_nextAnimation, numberOfReps = 2, reverse = false, callback) {
-    'worklet';
-    console.warn('Method `repeat` is deprecated. Please use `withRepeat` instead');
-    return withRepeat(_nextAnimation, numberOfReps, reverse, callback);
-}
-export function loop(nextAnimation, numberOfLoops = 1) {
-    'worklet';
-    console.warn('Method `loop` is deprecated. Please use `withRepeat` instead');
-    return repeat(nextAnimation, Math.round(numberOfLoops * 2), true);
-}

package/lib/reanimated2/animation/sequence.js

@@ -1,69 +0,0 @@
-import { defineAnimation } from './util';
-export function withSequence(..._animations) {
-    'worklet';
-    return defineAnimation(_animations[0], () => {
-        'worklet';
-        const animations = _animations.map((a) => {
-            const result = typeof a === 'function' ? a() : a;
-            result.finished = false;
-            return result;
-        });
-        const firstAnimation = animations[0];
-        const callback = (finished) => {
-            if (finished) {
-                // we want to call the callback after every single animation
-                // not after all of them
-                return;
-            }
-            // this is going to be called only if sequence has been cancelled
-            animations.forEach((animation) => {
-                if (typeof animation.callback === 'function' && !animation.finished) {
-                    animation.callback(finished);
-                }
-            });
-        };
-        function sequence(animation, now) {
-            const currentAnim = animations[animation.animationIndex];
-            const finished = currentAnim.onFrame(currentAnim, now);
-            animation.current = currentAnim.current;
-            if (finished) {
-                // we want to call the callback after every single animation
-                if (currentAnim.callback) {
-                    currentAnim.callback(true /* finished */);
-                }
-                currentAnim.finished = true;
-                animation.animationIndex += 1;
-                if (animation.animationIndex < animations.length) {
-                    const nextAnim = animations[animation.animationIndex];
-                    nextAnim.onStart(nextAnim, currentAnim.current, now, currentAnim);
-                    return false;
-                }
-                return true;
-            }
-            return false;
-        }
-        function onStart(animation, value, now, previousAnimation) {
-            animation.animationIndex = 0;
-            if (previousAnimation === undefined) {
-                previousAnimation = animations[animations.length - 1];
-            }
-            firstAnimation.onStart(firstAnimation, value, now, previousAnimation);
-        }
-        return {
-            isHigherOrder: true,
-            onFrame: sequence,
-            onStart,
-            animationIndex: 0,
-            current: firstAnimation.current,
-            callback,
-        };
-    });
-}
-/**
- * @deprecated Kept for backward compatibility. Will be removed soon.
- */
-export function sequence(..._animations) {
-    'worklet';
-    console.warn('Method `sequence` is deprecated. Please use `withSequence` instead');
-    return withSequence(..._animations);
-}

package/lib/reanimated2/animation/spring.js

@@ -1,103 +0,0 @@
-import { defineAnimation } from './util';
-export function withSpring(toValue, userConfig, callback) {
-    'worklet';
-    return defineAnimation(toValue, () => {
-        'worklet';
-        // TODO: figure out why we can't use spread or Object.assign here
-        // when user config is "frozen object" we can't enumerate it (perhaps
-        // something is wrong with the object prototype).
-        const config = {
-            damping: 10,
-            mass: 1,
-            stiffness: 100,
-            overshootClamping: false,
-            restDisplacementThreshold: 0.01,
-            restSpeedThreshold: 2,
-            velocity: 0,
-        };
-        if (userConfig) {
-            Object.keys(userConfig).forEach((key) => (config[key] = userConfig[key]));
-        }
-        function spring(animation, now) {
-            const { toValue, lastTimestamp, current, velocity } = animation;
-            const deltaTime = Math.min(now - lastTimestamp, 64);
-            animation.lastTimestamp = now;
-            const c = config.damping;
-            const m = config.mass;
-            const k = config.stiffness;
-            const v0 = -velocity;
-            const x0 = toValue - current;
-            const zeta = c / (2 * Math.sqrt(k * m)); // damping ratio
-            const omega0 = Math.sqrt(k / m); // undamped angular frequency of the oscillator (rad/ms)
-            const omega1 = omega0 * Math.sqrt(1 - Math.pow(zeta, 2)); // exponential decay
-            const t = deltaTime / 1000;
-            const sin1 = Math.sin(omega1 * t);
-            const cos1 = Math.cos(omega1 * t);
-            // under damped
-            const underDampedEnvelope = Math.exp(-zeta * omega0 * t);
-            const underDampedFrag1 = underDampedEnvelope *
-                (sin1 * ((v0 + zeta * omega0 * x0) / omega1) + x0 * cos1);
-            const underDampedPosition = toValue - underDampedFrag1;
-            // This looks crazy -- it's actually just the derivative of the oscillation function
-            const underDampedVelocity = zeta * omega0 * underDampedFrag1 -
-                underDampedEnvelope *
-                    (cos1 * (v0 + zeta * omega0 * x0) - omega1 * x0 * sin1);
-            // critically damped
-            const criticallyDampedEnvelope = Math.exp(-omega0 * t);
-            const criticallyDampedPosition = toValue - criticallyDampedEnvelope * (x0 + (v0 + omega0 * x0) * t);
-            const criticallyDampedVelocity = criticallyDampedEnvelope *
-                (v0 * (t * omega0 - 1) + t * x0 * omega0 * omega0);
-            const isOvershooting = () => {
-                if (config.overshootClamping && config.stiffness !== 0) {
-                    return current < toValue
-                        ? animation.current > toValue
-                        : animation.current < toValue;
-                }
-                else {
-                    return false;
-                }
-            };
-            const isVelocity = Math.abs(velocity) < config.restSpeedThreshold;
-            const isDisplacement = config.stiffness === 0 ||
-                Math.abs(toValue - current) < config.restDisplacementThreshold;
-            if (zeta < 1) {
-                animation.current = underDampedPosition;
-                animation.velocity = underDampedVelocity;
-            }
-            else {
-                animation.current = criticallyDampedPosition;
-                animation.velocity = criticallyDampedVelocity;
-            }
-            if (isOvershooting() || (isVelocity && isDisplacement)) {
-                if (config.stiffness !== 0) {
-                    animation.velocity = 0;
-                    animation.current = toValue;
-                }
-                // clear lastTimestamp to avoid using stale value by the next spring animation that starts after this one
-                animation.lastTimestamp = 0;
-                return true;
-            }
-            return false;
-        }
-        function onStart(animation, value, now, previousAnimation) {
-            animation.current = value;
-            if (previousAnimation) {
-                animation.velocity =
-                    previousAnimation.velocity || animation.velocity || 0;
-                animation.lastTimestamp = previousAnimation.lastTimestamp || now;
-            }
-            else {
-                animation.lastTimestamp = now;
-            }
-        }
-        return {
-            onFrame: spring,
-            onStart,
-            toValue,
-            velocity: config.velocity || 0,
-            current: toValue,
-            callback,
-            lastTimestamp: 0,
-        };
-    });
-}

package/lib/reanimated2/animation/styleAnimation.js

@@ -1,171 +0,0 @@
-import { defineAnimation } from './util';
-import { withTiming } from './timing';
-import { ColorProperties } from '../UpdateProps';
-import { processColor } from '../Colors';
-// resolves path to value for nested objects
-// if path cannot be resolved returns undefined
-export function resolvePath(obj, path) {
-    'worklet';
-    const keys = Array.isArray(path) ? path : [path];
-    return keys.reduce((acc, current) => {
-        if (Array.isArray(acc) && typeof current === 'number') {
-            return acc[current];
-        }
-        else if (typeof acc === 'object' && current in acc) {
-            return acc[current];
-        }
-        return undefined;
-    }, obj);
-}
-export function setPath(obj, path, value) {
-    'worklet';
-    const keys = Array.isArray(path) ? path : [path];
-    let currObj = obj;
-    for (let i = 0; i < keys.length - 1; i++) {
-        // creates entry if there isn't one
-        currObj = currObj;
-        if (!currObj[keys[i]]) {
-            // if next key is a number create an array
-            if (typeof keys[i + 1] === 'number') {
-                currObj[keys[i]] = [];
-            }
-            else {
-                currObj[keys[i]] = {};
-            }
-        }
-        currObj = currObj[keys[i]];
-    }
-    currObj[keys[keys.length - 1]] =
-        value;
-}
-export function withStyleAnimation(styleAnimations) {
-    'worklet';
-    return defineAnimation({}, () => {
-        'worklet';
-        const onFrame = (animation, now) => {
-            let stillGoing = false;
-            const entriesToCheck = [
-                { value: animation.styleAnimations, path: [] },
-            ];
-            while (entriesToCheck.length > 0) {
-                const currentEntry = entriesToCheck.pop();
-                if (Array.isArray(currentEntry.value)) {
-                    for (let index = 0; index < currentEntry.value.length; index++) {
-                        entriesToCheck.push({
-                            value: currentEntry.value[index],
-                            path: currentEntry.path.concat(index),
-                        });
-                    }
-                }
-                else if (typeof currentEntry.value === 'object' &&
-                    currentEntry.value.onFrame === undefined) {
-                    // nested object
-                    for (const key of Object.keys(currentEntry.value)) {
-                        entriesToCheck.push({
-                            value: currentEntry.value[key],
-                            path: currentEntry.path.concat(key),
-                        });
-                    }
-                }
-                else {
-                    const currentStyleAnimation = currentEntry.value;
-                    if (currentStyleAnimation.finished) {
-                        continue;
-                    }
-                    const finished = currentStyleAnimation.onFrame(currentStyleAnimation, now);
-                    if (finished) {
-                        currentStyleAnimation.finished = true;
-                        if (currentStyleAnimation.callback) {
-                            currentStyleAnimation.callback(true);
-                        }
-                    }
-                    else {
-                        stillGoing = true;
-                    }
-                    if (ColorProperties.includes(currentEntry.path[0])) {
-                        currentStyleAnimation.current = processColor(currentStyleAnimation.current);
-                    }
-                    setPath(animation.current, currentEntry.path, currentStyleAnimation.current);
-                }
-            }
-            return !stillGoing;
-        };
-        const onStart = (animation, value, now, previousAnimation) => {
-            const entriesToCheck = [{ value: styleAnimations, path: [] }];
-            while (entriesToCheck.length > 0) {
-                const currentEntry = entriesToCheck.pop();
-                if (Array.isArray(currentEntry.value)) {
-                    for (let index = 0; index < currentEntry.value.length; index++) {
-                        entriesToCheck.push({
-                            value: currentEntry.value[index],
-                            path: currentEntry.path.concat(index),
-                        });
-                    }
-                }
-                else if (typeof currentEntry.value === 'object' &&
-                    currentEntry.value.onStart === undefined) {
-                    for (const key of Object.keys(currentEntry.value)) {
-                        entriesToCheck.push({
-                            value: currentEntry.value[key],
-                            path: currentEntry.path.concat(key),
-                        });
-                    }
-                }
-                else {
-                    const prevAnimation = resolvePath(previousAnimation === null || previousAnimation === void 0 ? void 0 : previousAnimation.styleAnimations, currentEntry.path);
-                    let prevVal = resolvePath(value, currentEntry.path);
-                    if (prevAnimation && !prevVal) {
-                        prevVal = prevAnimation.current;
-                    }
-                    setPath(animation.current, currentEntry.path, prevVal);
-                    let currentAnimation;
-                    if (typeof currentEntry.value !== 'object' ||
-                        !currentEntry.value.onStart) {
-                        currentAnimation = withTiming(currentEntry.value, { duration: 0 });
-                        setPath(animation.styleAnimations, currentEntry.path, currentAnimation);
-                    }
-                    else {
-                        currentAnimation = currentEntry.value;
-                    }
-                    currentAnimation.onStart(currentAnimation, prevVal, now, prevAnimation);
-                }
-            }
-        };
-        const callback = (finished) => {
-            if (!finished) {
-                const animationsToCheck = [
-                    styleAnimations,
-                ];
-                while (animationsToCheck.length > 0) {
-                    const currentAnimation = animationsToCheck.pop();
-                    if (Array.isArray(currentAnimation)) {
-                        for (const element of currentAnimation) {
-                            animationsToCheck.push(element);
-                        }
-                    }
-                    else if (typeof currentAnimation === 'object' &&
-                        currentAnimation.onStart === undefined) {
-                        for (const value of Object.values(currentAnimation)) {
-                            animationsToCheck.push(value);
-                        }
-                    }
-                    else {
-                        const currentStyleAnimation = currentAnimation;
-                        if (!currentStyleAnimation.finished &&
-                            currentStyleAnimation.callback) {
-                            currentStyleAnimation.callback(false);
-                        }
-                    }
-                }
-            }
-        };
-        return {
-            isHigherOrder: true,
-            onFrame,
-            onStart,
-            current: {},
-            styleAnimations,
-            callback,
-        };
-    });
-}

package/lib/reanimated2/animation/timing.js

@@ -1,64 +0,0 @@
-import { Easing } from '../Easing';
-import { defineAnimation } from './util';
-export function withTiming(toValue, userConfig, callback) {
-    'worklet';
-    return defineAnimation(toValue, () => {
-        'worklet';
-        const config = {
-            duration: 300,
-            easing: Easing.inOut(Easing.quad),
-        };
-        if (userConfig) {
-            Object.keys(userConfig).forEach((key) => (config[key] = userConfig[key]));
-        }
-        function timing(animation, now) {
-            const { toValue, startTime, startValue } = animation;
-            const runtime = now - startTime;
-            if (runtime >= config.duration) {
-                // reset startTime to avoid reusing finished animation config in `start` method
-                animation.startTime = 0;
-                animation.current = toValue;
-                return true;
-            }
-            const progress = animation.easing(runtime / config.duration);
-            animation.current =
-                startValue + (toValue - startValue) * progress;
-            return false;
-        }
-        function onStart(animation, value, now, previousAnimation) {
-            if (previousAnimation &&
-                previousAnimation.type === 'timing' &&
-                previousAnimation.toValue === toValue &&
-                previousAnimation.startTime) {
-                // to maintain continuity of timing animations we check if we are starting
-                // new timing over the old one with the same parameters. If so, we want
-                // to copy animation timeline properties
-                animation.startTime = previousAnimation.startTime;
-                animation.startValue = previousAnimation.startValue;
-            }
-            else {
-                animation.startTime = now;
-                animation.startValue = value;
-            }
-            animation.current = value;
-            if (typeof config.easing === 'object') {
-                animation.easing = config.easing.factory();
-            }
-            else {
-                animation.easing = config.easing;
-            }
-        }
-        return {
-            type: 'timing',
-            onFrame: timing,
-            onStart: onStart,
-            progress: 0,
-            toValue,
-            startValue: 0,
-            startTime: 0,
-            easing: () => 0,
-            current: toValue,
-            callback,
-        };
-    });
-}