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

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

@@ -1,43 +0,0 @@
-import MutableValue from './MutableValue';
-export default class Mapper {
-    constructor(module, mapper, inputs = [], outputs = []) {
-        this.dirty = true;
-        this.id = Mapper.MAPPER_ID++;
-        this.inputs = this.extractMutablesFromArray(inputs);
-        this.outputs = this.extractMutablesFromArray(outputs);
-        this.mapper = mapper;
-        const markDirty = () => {
-            this.dirty = true;
-            module.maybeRequestRender();
-        };
-        this.inputs.forEach((input) => {
-            input.addListener(markDirty);
-        });
-    }
-    execute() {
-        this.dirty = false;
-        this.mapper();
-    }
-    extractMutablesFromArray(array) {
-        const res = [];
-        function extractMutables(value) {
-            if (value == null) {
-                // return;
-            }
-            else if (value instanceof MutableValue) {
-                res.push(value);
-            }
-            else if (Array.isArray(value)) {
-                value.forEach((v) => extractMutables(v));
-            }
-            else if (typeof value === 'object') {
-                Object.keys(value).forEach((key) => {
-                    extractMutables(value[key]);
-                });
-            }
-        }
-        extractMutables(array);
-        return res;
-    }
-}
-Mapper.MAPPER_ID = 1;

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,25 +0,0 @@
-// In order to keep bundle size down, we treat this file as a polyfill for Web.
-import { shouldBeUseWeb } from '../PlatformChecker';
-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");
-    };
-}

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 = {};
-    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];
-    }
-}