react-native-reanimated 2.14.4 → 2.16.0

package/lib/reanimated2/js-reanimated/MapperRegistry.js

@@ -1,101 +0,0 @@
-export default class MapperRegistry {
-    constructor(module) {
-        this.sortedMappers = [];
-        this.mappers = new Map();
-        this.updatedSinceLastExecute = false;
-        this._module = module;
-    }
-    startMapper(mapper) {
-        this.mappers.set(mapper.id, mapper);
-        this.updatedSinceLastExecute = true;
-        return mapper.id;
-    }
-    stopMapper(id) {
-        this.mappers.delete(id);
-        this.updatedSinceLastExecute = true;
-    }
-    execute() {
-        if (this.updatedSinceLastExecute) {
-            this.updateOrder();
-            this.updatedSinceLastExecute = false;
-        }
-        for (let i = 0, len = this.sortedMappers.length; i < len; ++i) {
-            const mapper = this.sortedMappers[i];
-            if (mapper.dirty) {
-                mapper.execute();
-            }
-        }
-    }
-    updateOrder() {
-        const nodes = [...this.mappers.values()].map((mapper) => new Node(mapper));
-        const mappersById = {};
-        this.mappers.forEach((mapper) => {
-            mappersById[mapper.id] = mapper;
-        });
-        // create a graph from array of nodes
-        for (let i = 0, nodesLen = nodes.length; i < nodesLen; ++i) {
-            const node = nodes[i];
-            if (node.mapper.outputs.length === 0) {
-                continue;
-            }
-            for (let j = 0; j < nodesLen; ++j) {
-                const restNode = nodes[j];
-                if (i === j || restNode.mapper.inputs.length === 0) {
-                    continue;
-                }
-                for (let outi = 0, outputsLen = node.mapper.outputs.length; outi < outputsLen; ++outi) {
-                    for (let resti = 0, restLen = restNode.mapper.inputs.length; resti < restLen; ++resti) {
-                        if (node.mapper.outputs[outi]._id ===
-                            restNode.mapper.inputs[resti]._id) {
-                            node.children.push(restNode);
-                        }
-                    }
-                }
-            }
-        }
-        const post = {};
-        let postCounter = 1;
-        const dfs = (node) => {
-            const index = nodes.indexOf(node);
-            if (index === -1) {
-                // this node has already been handled
-                return;
-            }
-            ++postCounter;
-            nodes.splice(index, 1);
-            if (node.children.length === 0 && nodes.length > 0) {
-                post[node.mapper.id] = postCounter++;
-                dfs(nodes[0]);
-                return;
-            }
-            for (let i = 0, len = node.children.length; i < len; ++i) {
-                dfs(node.children[i]);
-            }
-            post[node.mapper.id] = postCounter++;
-        };
-        while (nodes.length)
-            dfs(nodes[0]);
-        const postArray = Object.keys(post).map((key) => {
-            const num = parseInt(key);
-            return [num, post[num]];
-        });
-        postArray.sort((a, b) => {
-            return b[1] - a[1];
-        });
-        // clear sorted mappers
-        this.sortedMappers = [];
-        for (let i = 0, len = postArray.length; i < len; ++i) {
-            const [id] = postArray[i];
-            this.sortedMappers.push(mappersById[id]);
-        }
-    }
-    get needRunOnRender() {
-        return this.updatedSinceLastExecute;
-    }
-}
-class Node {
-    constructor(mapper, children = []) {
-        this.mapper = mapper;
-        this.children = children;
-    }
-}

package/lib/reanimated2/js-reanimated/MutableValue.js

@@ -1,29 +0,0 @@
-export default class MutableValue {
-    constructor(value, setter) {
-        this._animation = null;
-        this._listeners = [];
-        this._id = MutableValue.MUTABLE_ID++;
-        this._value = value;
-        this._setter = setter;
-    }
-    get value() {
-        return this._value;
-    }
-    set value(nextValue) {
-        this._setter(nextValue);
-    }
-    // this changes the value finally and is supposed to be called from this._setter
-    _setValue(newValue) {
-        this._value = newValue;
-        this._triggerListener();
-    }
-    addListener(listener) {
-        this._listeners.push(listener);
-    }
-    _triggerListener() {
-        for (let i = 0, len = this._listeners.length; i < len; ++i) {
-            this._listeners[i]();
-        }
-    }
-}
-MutableValue.MUTABLE_ID = 1;

package/lib/reanimated2/js-reanimated/commonTypes.js

@@ -1 +0,0 @@
-export {};

package/lib/reanimated2/js-reanimated/global.js

@@ -1,36 +0,0 @@
-// In order to keep bundle size down, we treat this file as a polyfill for Web.
-import { shouldBeUseWeb } from '../PlatformChecker';
-const initializeGlobalsForWeb = () => {
-    if (shouldBeUseWeb()) {
-        global._frameTimestamp = null;
-        global._setGlobalConsole = (_val) => {
-            // noop
-        };
-        global._measure = () => {
-            console.warn("[Reanimated] You can't use `measure` with Chrome Debugger or with web version");
-            return {
-                x: 0,
-                y: 0,
-                width: 0,
-                height: 0,
-                pageX: 0,
-                pageY: 0,
-            };
-        };
-        global._scrollTo = () => {
-            console.warn("[Reanimated] You can't use `scrollTo` with Chrome Debugger or with web version");
-        };
-        global._setGestureState = () => {
-            console.warn("[Reanimated] You can't use `setGestureState` with Chrome Debugger or with web version");
-        };
-    }
-    return true;
-};
-/*
-  If a file doesn't export anything, tree shaking doesn't pack
-  it into the JS bundle. In effect, the code inside of this file
-  will never execute. That is why we wrapped initialization code
-  into a function, and we call this one during creating
-  the module export object.
-*/
-export default initializeGlobalsForWeb();

package/lib/reanimated2/js-reanimated/index.js

@@ -1,35 +0,0 @@
-import JSReanimated from './JSReanimated';
-const reanimatedJS = new JSReanimated();
-export const _updatePropsJS = (updates, viewRef) => {
-    if (viewRef._component) {
-        const component = viewRef._component;
-        const [rawStyles] = Object.keys(updates).reduce((acc, key) => {
-            const value = updates[key];
-            const index = typeof value === 'function' ? 1 : 0;
-            acc[index][key] = value;
-            return acc;
-        }, [{}, {}]);
-        if (typeof component.setNativeProps === 'function') {
-            setNativeProps(component, rawStyles);
-        }
-        else if (Object.keys(component.props).length > 0) {
-            Object.keys(component.props).forEach((key) => {
-                if (!rawStyles[key]) {
-                    return;
-                }
-                const dashedKey = key.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase());
-                component._touchableNode.setAttribute(dashedKey, rawStyles[key]);
-            });
-        }
-        else {
-            console.warn('It is not possible to manipulate component');
-        }
-    }
-};
-const setNativeProps = (component, style) => {
-    const previousStyle = component.previousStyle ? component.previousStyle : {};
-    const currentStyle = Object.assign(Object.assign({}, previousStyle), style);
-    component.previousStyle = currentStyle;
-    component.setNativeProps({ style: currentStyle });
-};
-export default reanimatedJS;

package/lib/reanimated2/layoutReanimation/LayoutAnimationRepository.js

@@ -1,67 +0,0 @@
-/* global _stopObservingProgress, _startObservingProgress */
-import { runOnUI } from '../core';
-import { withStyleAnimation } from '../animation/styleAnimation';
-import { ColorProperties } from '../UpdateProps';
-import { processColor } from '../Colors';
-runOnUI(() => {
-    'worklet';
-    const configs = Object.create(null);
-    const enteringAnimationForTag = {};
-    global.LayoutAnimationRepository = {
-        configs,
-        registerConfig(tag, config) {
-            configs[tag] = config;
-            enteringAnimationForTag[tag] = null;
-        },
-        removeConfig(tag) {
-            delete configs[tag];
-            delete enteringAnimationForTag[tag];
-        },
-        startAnimationForTag(tag, type, yogaValues) {
-            if (configs[tag] == null) {
-                return; // :(
-            }
-            const style = configs[tag][type](yogaValues);
-            let currentAnimation = style.animations;
-            if (type === 'entering') {
-                enteringAnimationForTag[tag] = style;
-            }
-            else if (type === 'layout' && enteringAnimationForTag[tag] !== null) {
-                const entryAniamtion = enteringAnimationForTag[tag].animations;
-                const layoutAnimation = style.animations;
-                currentAnimation = {};
-                for (const key in entryAniamtion) {
-                    currentAnimation[key] = entryAniamtion[key];
-                }
-                for (const key in layoutAnimation) {
-                    currentAnimation[key] = layoutAnimation[key];
-                }
-            }
-            const sv = configs[tag].sv;
-            _stopObservingProgress(tag, false);
-            _startObservingProgress(tag, sv);
-            const backupColor = {};
-            for (const key in style.initialValues) {
-                if (ColorProperties.includes(key)) {
-                    const value = style.initialValues[key];
-                    backupColor[key] = value;
-                    style.initialValues[key] = processColor(value);
-                }
-            }
-            sv.value = Object.assign({}, sv._value, style.initialValues);
-            _stopObservingProgress(tag, false);
-            const animation = withStyleAnimation(currentAnimation);
-            animation.callback = (finished) => {
-                if (finished) {
-                    _stopObservingProgress(tag, finished);
-                }
-                style.callback && style.callback(finished);
-            };
-            if (backupColor) {
-                configs[tag].sv._value = Object.assign(Object.assign({}, configs[tag].sv.value), backupColor);
-            }
-            configs[tag].sv.value = animation;
-            _startObservingProgress(tag, sv);
-        },
-    };
-})();

package/lib/reanimated2/layoutReanimation/animationBuilder/BaseAnimationBuilder.js

@@ -1,69 +0,0 @@
-import { withDelay } from '../../animation';
-export class BaseAnimationBuilder {
-    constructor() {
-        this.randomizeDelay = false;
-        this.build = () => {
-            throw Error('Unimplemented method in child class.');
-        };
-    }
-    static duration(durationMs) {
-        const instance = this.createInstance();
-        return instance.duration(durationMs);
-    }
-    duration(durationMs) {
-        this.durationV = durationMs;
-        return this;
-    }
-    static delay(delayMs) {
-        const instance = this.createInstance();
-        return instance.delay(delayMs);
-    }
-    delay(delayMs) {
-        this.delayV = delayMs;
-        return this;
-    }
-    static withCallback(callback) {
-        const instance = this.createInstance();
-        return instance.withCallback(callback);
-    }
-    withCallback(callback) {
-        this.callbackV = callback;
-        return this;
-    }
-    // 300ms is the default animation duration. If any animation has different default has to override this method.
-    static getDuration() {
-        return 300;
-    }
-    getDuration() {
-        var _a;
-        return (_a = this.durationV) !== null && _a !== void 0 ? _a : 300;
-    }
-    static randomDelay() {
-        const instance = this.createInstance();
-        return instance.randomDelay();
-    }
-    randomDelay() {
-        this.randomizeDelay = true;
-        return this;
-    }
-    // when randomizeDelay is set to true, randomize delay between 0 and provided value (or 1000ms if delay is not provided)
-    getDelay() {
-        var _a, _b;
-        return this.randomizeDelay
-            ? Math.random() * ((_a = this.delayV) !== null && _a !== void 0 ? _a : 1000)
-            : (_b = this.delayV) !== null && _b !== void 0 ? _b : 0;
-    }
-    getDelayFunction() {
-        const isDelayProvided = this.randomizeDelay || this.delayV;
-        return isDelayProvided
-            ? withDelay
-            : (_, animation) => {
-                'worklet';
-                return animation;
-            };
-    }
-    static build() {
-        const instance = this.createInstance();
-        return instance.build();
-    }
-}

package/lib/reanimated2/layoutReanimation/animationBuilder/ComplexAnimationBuilder.js

@@ -1,133 +0,0 @@
-import { withTiming, withSpring } from '../../animation';
-import { BaseAnimationBuilder } from './BaseAnimationBuilder';
-export class ComplexAnimationBuilder extends BaseAnimationBuilder {
-    static easing(easingFunction) {
-        const instance = this.createInstance();
-        return instance.easing(easingFunction);
-    }
-    easing(easingFunction) {
-        this.easingV = easingFunction;
-        return this;
-    }
-    static rotate(degree) {
-        const instance = this.createInstance();
-        return instance.rotate(degree);
-    }
-    rotate(degree) {
-        this.rotateV = degree;
-        return this;
-    }
-    static springify() {
-        const instance = this.createInstance();
-        return instance.springify();
-    }
-    springify() {
-        this.type = withSpring;
-        return this;
-    }
-    static damping(damping) {
-        const instance = this.createInstance();
-        return instance.damping(damping);
-    }
-    damping(damping) {
-        this.dampingV = damping;
-        return this;
-    }
-    static mass(mass) {
-        const instance = this.createInstance();
-        return instance.mass(mass);
-    }
-    mass(mass) {
-        this.massV = mass;
-        return this;
-    }
-    static stiffness(stiffness) {
-        const instance = this.createInstance();
-        return instance.stiffness(stiffness);
-    }
-    stiffness(stiffness) {
-        this.stiffnessV = stiffness;
-        return this;
-    }
-    static overshootClamping(overshootClamping) {
-        const instance = this.createInstance();
-        return instance.overshootClamping(overshootClamping);
-    }
-    overshootClamping(overshootClamping) {
-        this.overshootClampingV = overshootClamping;
-        return this;
-    }
-    static restDisplacementThreshold(restDisplacementThreshold) {
-        const instance = this.createInstance();
-        return instance.restDisplacementThreshold(restDisplacementThreshold);
-    }
-    restDisplacementThreshold(restDisplacementThreshold) {
-        this.restDisplacementThresholdV = restDisplacementThreshold;
-        return this;
-    }
-    static restSpeedThreshold(restSpeedThreshold) {
-        const instance = this.createInstance();
-        return instance.restSpeedThreshold(restSpeedThreshold);
-    }
-    restSpeedThreshold(restSpeedThreshold) {
-        this.restSpeedThresholdV = restSpeedThreshold;
-        return this;
-    }
-    static withInitialValues(values) {
-        const instance = this.createInstance();
-        return instance.withInitialValues(values);
-    }
-    withInitialValues(values) {
-        this.initialValues = values;
-        return this;
-    }
-    getAnimationAndConfig() {
-        const duration = this.durationV;
-        const easing = this.easingV;
-        const rotate = this.rotateV;
-        const type = this.type ? this.type : withTiming;
-        const damping = this.dampingV;
-        const mass = this.massV;
-        const stiffness = this.stiffnessV;
-        const overshootClamping = this.overshootClampingV;
-        const restDisplacementThreshold = this.restDisplacementThresholdV;
-        const restSpeedThreshold = this.restSpeedThresholdV;
-        const animation = type;
-        const config = {};
-        if (type === withTiming) {
-            if (easing) {
-                config.easing = easing;
-            }
-            if (duration) {
-                config.duration = duration;
-            }
-            if (rotate) {
-                config.rotate = rotate;
-            }
-        }
-        else {
-            if (damping) {
-                config.damping = damping;
-            }
-            if (mass) {
-                config.mass = mass;
-            }
-            if (stiffness) {
-                config.stiffness = stiffness;
-            }
-            if (overshootClamping) {
-                config.overshootClamping = overshootClamping;
-            }
-            if (restDisplacementThreshold) {
-                config.restDisplacementThreshold = restDisplacementThreshold;
-            }
-            if (restSpeedThreshold) {
-                config.restSpeedThreshold = restSpeedThreshold;
-            }
-            if (rotate) {
-                config.rotate = rotate;
-            }
-        }
-        return [animation, config];
-    }
-}

package/lib/reanimated2/layoutReanimation/animationBuilder/Keyframe.js

@@ -1,194 +0,0 @@
-import { Easing } from '../../Easing';
-import { withDelay, withSequence, withTiming } from '../../animation';
-export class Keyframe {
-    /*
-      Keyframe definition should be passed in the constructor as the map
-      which keys are between range 0 - 100 (%) and correspond to the point in the animation progress.
-    */
-    constructor(definitions) {
-        this.build = () => {
-            const delay = this.delayV;
-            const delayFunction = this.getDelayFunction();
-            const { keyframes, initialValues } = this.parseDefinitions();
-            const callback = this.callbackV;
-            return (_targetValues) => {
-                'worklet';
-                const animations = {};
-                /*
-                      For each style property, an animations sequence is created that corresponds with its key points.
-                      Transform style properties require special handling because of their nested structure.
-                */
-                const addAnimation = (key) => {
-                    var _a;
-                    const keyframePoints = keyframes[key];
-                    // in case if property was only passed as initial value
-                    if (keyframePoints.length === 0)
-                        return;
-                    const animation = delayFunction(delay, keyframePoints.length === 1
-                        ? withTiming(keyframePoints[0].value, {
-                            duration: keyframePoints[0].duration,
-                            easing: keyframePoints[0].easing
-                                ? keyframePoints[0].easing
-                                : Easing.linear,
-                        })
-                        : withSequence.apply(this, keyframePoints.map((keyframePoint) => withTiming(keyframePoint.value, {
-                            duration: keyframePoint.duration,
-                            easing: keyframePoint.easing
-                                ? keyframePoint.easing
-                                : Easing.linear,
-                        }))));
-                    if (key.includes('transform')) {
-                        if (!('transform' in animations)) {
-                            animations.transform = [];
-                        }
-                        (_a = animations.transform) === null || _a === void 0 ? void 0 : _a.push({
-                            [key.split(':')[1]]: animation,
-                        });
-                    }
-                    else {
-                        animations[key] = animation;
-                    }
-                };
-                Object.keys(initialValues).forEach((key) => {
-                    if (key.includes('transform')) {
-                        initialValues[key].forEach((transformProp, index) => {
-                            Object.keys(transformProp).forEach((transformPropKey) => {
-                                addAnimation(index.toString() + '_transform:' + transformPropKey);
-                            });
-                        });
-                    }
-                    else {
-                        addAnimation(key);
-                    }
-                });
-                return {
-                    animations: animations,
-                    initialValues: initialValues,
-                    callback: callback,
-                };
-            };
-        };
-        this.definitions = definitions;
-    }
-    parseDefinitions() {
-        /*
-            Each style property contain an array with all their key points:
-            value, duration of transition to that value, and optional easing function (defaults to Linear)
-        */
-        const parsedKeyframes = {};
-        /*
-          Parsing keyframes 'from' and 'to'.
-        */
-        if (this.definitions.from) {
-            if (this.definitions['0']) {
-                throw Error("You cannot provide both keyframe 0 and 'from' as they both specified initial values");
-            }
-            this.definitions['0'] = this.definitions.from;
-            delete this.definitions.from;
-        }
-        if (this.definitions.to) {
-            if (this.definitions['100']) {
-                throw Error("You cannot provide both keyframe 100 and 'to' as they both specified values at the end of the animation.");
-            }
-            this.definitions['100'] = this.definitions.to;
-            delete this.definitions.to;
-        }
-        /*
-           One of the assumptions is that keyframe  0 is required to properly set initial values.
-           Every other keyframe should contain properties from the set provided as initial values.
-        */
-        if (!this.definitions['0']) {
-            throw Error("Please provide 0, or 'from' keyframe with initial state of your object.");
-        }
-        const initialValues = this.definitions['0'];
-        /*
-          Initialize parsedKeyframes for properties provided in initial keyframe
-        */
-        Object.keys(initialValues).forEach((styleProp) => {
-            var _a;
-            if (styleProp === 'transform') {
-                (_a = initialValues[styleProp]) === null || _a === void 0 ? void 0 : _a.forEach((transformStyle, index) => {
-                    Object.keys(transformStyle).forEach((transformProp) => {
-                        parsedKeyframes[index.toString() + '_transform:' + transformProp] =
-                            [];
-                    });
-                });
-            }
-            else {
-                parsedKeyframes[styleProp] = [];
-            }
-        });
-        const duration = this.durationV ? this.durationV : 500;
-        const animationKeyPoints = Array.from(Object.keys(this.definitions));
-        const getAnimationDuration = (key, currentKeyPoint) => {
-            const maxDuration = (currentKeyPoint / 100) * duration;
-            const currentDuration = parsedKeyframes[key].reduce((acc, value) => acc + value.duration, 0);
-            return maxDuration - currentDuration;
-        };
-        /*
-           Other keyframes can't contain properties that were not specified in initial keyframe.
-        */
-        const addKeyPoint = ({ key, value, currentKeyPoint, easing, }) => {
-            if (!(key in parsedKeyframes)) {
-                throw Error("Keyframe can contain only that set of properties that were provide with initial values (keyframe 0 or 'from')");
-            }
-            parsedKeyframes[key].push({
-                duration: getAnimationDuration(key, currentKeyPoint),
-                value: value,
-                easing: easing,
-            });
-        };
-        animationKeyPoints
-            .filter((value) => parseInt(value) !== 0)
-            .sort((a, b) => parseInt(a) - parseInt(b))
-            .forEach((keyPoint) => {
-            if (parseInt(keyPoint) < 0 || parseInt(keyPoint) > 100) {
-                throw Error('Keyframe should be in between range 0 - 100.');
-            }
-            const keyframe = this.definitions[keyPoint];
-            const easing = keyframe.easing;
-            delete keyframe.easing;
-            const addKeyPointWith = (key, value) => addKeyPoint({
-                key,
-                value,
-                currentKeyPoint: parseInt(keyPoint),
-                easing,
-            });
-            Object.keys(keyframe).forEach((key) => {
-                var _a;
-                if (key === 'transform') {
-                    (_a = keyframe[key]) === null || _a === void 0 ? void 0 : _a.forEach((transformStyle, index) => {
-                        Object.keys(transformStyle).forEach((transformProp) => {
-                            addKeyPointWith(index.toString() + '_transform:' + transformProp, transformStyle[transformProp]);
-                        });
-                    });
-                }
-                else {
-                    addKeyPointWith(key, keyframe[key]);
-                }
-            });
-        });
-        return { initialValues: initialValues, keyframes: parsedKeyframes };
-    }
-    duration(durationMs) {
-        this.durationV = durationMs;
-        return this;
-    }
-    delay(delayMs) {
-        this.delayV = delayMs;
-        return this;
-    }
-    withCallback(callback) {
-        this.callbackV = callback;
-        return this;
-    }
-    getDelayFunction() {
-        const delay = this.delayV;
-        return delay
-            ? withDelay
-            : (_, animation) => {
-                'worklet';
-                return animation;
-            };
-    }
-}

package/lib/reanimated2/layoutReanimation/animationBuilder/commonTypes.js

@@ -1 +0,0 @@
-export {};

package/lib/reanimated2/layoutReanimation/animationBuilder/index.js

@@ -1,3 +0,0 @@
-export { BaseAnimationBuilder } from './BaseAnimationBuilder';
-export { ComplexAnimationBuilder } from './ComplexAnimationBuilder';
-export { Keyframe } from './Keyframe';