react-native-reanimated 2.15.0 → 2.16.0

package/lib/reanimated2/animation/util.js

@@ -1,183 +0,0 @@
-/* global _WORKLET */
-import { isColor, convertToRGBA, rgbaArrayToRGBAColor, toGammaSpace, toLinearSpace, } from '../Colors';
-import NativeReanimatedModule from '../NativeReanimated';
-let IN_STYLE_UPDATER = false;
-export function initialUpdaterRun(updater) {
-    IN_STYLE_UPDATER = true;
-    const result = updater();
-    IN_STYLE_UPDATER = false;
-    return result;
-}
-function recognizePrefixSuffix(value) {
-    'worklet';
-    var _a;
-    if (typeof value === 'string') {
-        const match = value.match(/([A-Za-z]*)(-?\d*\.?\d*)([eE][-+]?[0-9]+)?([A-Za-z%]*)/);
-        if (!match) {
-            throw Error("Couldn't parse animation value. Check if there isn't any typo.");
-        }
-        const prefix = match[1];
-        const suffix = match[4];
-        // number with scientific notation
-        const number = match[2] + ((_a = match[3]) !== null && _a !== void 0 ? _a : '');
-        return { prefix, suffix, strippedValue: parseFloat(number) };
-    }
-    else {
-        return { strippedValue: value };
-    }
-}
-function decorateAnimation(animation) {
-    'worklet';
-    if (animation.isHigherOrder) {
-        return;
-    }
-    const baseOnStart = animation.onStart;
-    const baseOnFrame = animation.onFrame;
-    const animationCopy = Object.assign({}, animation);
-    delete animationCopy.callback;
-    const prefNumberSuffOnStart = (animation, value, timestamp, previousAnimation) => {
-        var _a, _b, _c, _d;
-        // recognize prefix, suffix, and updates stripped value on animation start
-        const { prefix, suffix, strippedValue } = recognizePrefixSuffix(value);
-        animation.__prefix = prefix;
-        animation.__suffix = suffix;
-        animation.strippedCurrent = strippedValue;
-        const { strippedValue: strippedToValue } = recognizePrefixSuffix(animation.toValue);
-        animation.current = strippedValue;
-        animation.startValue = strippedValue;
-        animation.toValue = strippedToValue;
-        if (previousAnimation && previousAnimation !== animation) {
-            const { prefix: paPrefix, suffix: paSuffix, strippedValue: paStrippedValue, } = recognizePrefixSuffix(previousAnimation.current);
-            previousAnimation.current = paStrippedValue;
-            previousAnimation.__prefix = paPrefix;
-            previousAnimation.__suffix = paSuffix;
-        }
-        baseOnStart(animation, strippedValue, timestamp, previousAnimation);
-        animation.current =
-            ((_a = animation.__prefix) !== null && _a !== void 0 ? _a : '') +
-                animation.current +
-                ((_b = animation.__suffix) !== null && _b !== void 0 ? _b : '');
-        if (previousAnimation && previousAnimation !== animation) {
-            previousAnimation.current =
-                ((_c = previousAnimation.__prefix) !== null && _c !== void 0 ? _c : '') +
-                    previousAnimation.current +
-                    ((_d = previousAnimation.__suffix) !== null && _d !== void 0 ? _d : '');
-        }
-    };
-    const prefNumberSuffOnFrame = (animation, timestamp) => {
-        var _a, _b;
-        animation.current = animation.strippedCurrent;
-        const res = baseOnFrame(animation, timestamp);
-        animation.strippedCurrent = animation.current;
-        animation.current =
-            ((_a = animation.__prefix) !== null && _a !== void 0 ? _a : '') +
-                animation.current +
-                ((_b = animation.__suffix) !== null && _b !== void 0 ? _b : '');
-        return res;
-    };
-    const tab = ['R', 'G', 'B', 'A'];
-    const colorOnStart = (animation, value, timestamp, previousAnimation) => {
-        let RGBAValue;
-        let RGBACurrent;
-        let RGBAToValue;
-        const res = [];
-        if (isColor(value)) {
-            RGBACurrent = toLinearSpace(convertToRGBA(animation.current));
-            RGBAValue = toLinearSpace(convertToRGBA(value));
-            if (animation.toValue) {
-                RGBAToValue = toLinearSpace(convertToRGBA(animation.toValue));
-            }
-        }
-        tab.forEach((i, index) => {
-            animation[i] = Object.assign({}, animationCopy);
-            animation[i].current = RGBACurrent[index];
-            animation[i].toValue = RGBAToValue ? RGBAToValue[index] : undefined;
-            animation[i].onStart(animation[i], RGBAValue[index], timestamp, previousAnimation ? previousAnimation[i] : undefined);
-            res.push(animation[i].current);
-        });
-        animation.current = rgbaArrayToRGBAColor(toGammaSpace(res));
-    };
-    const colorOnFrame = (animation, timestamp) => {
-        const RGBACurrent = toLinearSpace(convertToRGBA(animation.current));
-        const res = [];
-        let finished = true;
-        tab.forEach((i, index) => {
-            animation[i].current = RGBACurrent[index];
-            // @ts-ignore: disable-next-line
-            finished &= animation[i].onFrame(animation[i], timestamp);
-            res.push(animation[i].current);
-        });
-        animation.current = rgbaArrayToRGBAColor(toGammaSpace(res));
-        return finished;
-    };
-    const arrayOnStart = (animation, value, timestamp, previousAnimation) => {
-        value.forEach((v, i) => {
-            animation[i] = Object.assign({}, animationCopy);
-            animation[i].current = v;
-            animation[i].toValue = animation.toValue[i];
-            animation[i].onStart(animation[i], v, timestamp, previousAnimation ? previousAnimation[i] : undefined);
-        });
-        animation.current = value;
-    };
-    const arrayOnFrame = (animation, timestamp) => {
-        let finished = true;
-        animation.current.forEach((v, i) => {
-            // @ts-ignore: disable-next-line
-            finished &= animation[i].onFrame(animation[i], timestamp);
-            animation.current[i] = animation[i].current;
-        });
-        return finished;
-    };
-    animation.onStart = (animation, value, timestamp, previousAnimation) => {
-        if (isColor(value)) {
-            colorOnStart(animation, value, timestamp, previousAnimation);
-            animation.onFrame = colorOnFrame;
-            return;
-        }
-        else if (Array.isArray(value)) {
-            arrayOnStart(animation, value, timestamp, previousAnimation);
-            animation.onFrame = arrayOnFrame;
-            return;
-        }
-        else if (typeof value === 'string') {
-            prefNumberSuffOnStart(animation, value, timestamp, previousAnimation);
-            animation.onFrame = prefNumberSuffOnFrame;
-            return;
-        }
-        baseOnStart(animation, value, timestamp, previousAnimation);
-    };
-}
-export function defineAnimation(starting, factory) {
-    'worklet';
-    if (IN_STYLE_UPDATER) {
-        return starting;
-    }
-    const create = () => {
-        'worklet';
-        const animation = factory();
-        decorateAnimation(animation);
-        return animation;
-    };
-    if (_WORKLET || !NativeReanimatedModule.native) {
-        return create();
-    }
-    // @ts-ignore: eslint-disable-line
-    return create;
-}
-export function cancelAnimation(sharedValue) {
-    'worklet';
-    // setting the current value cancels the animation if one is currently running
-    sharedValue.value = sharedValue.value; // eslint-disable-line no-self-assign
-}
-// TODO it should work only if there was no animation before.
-export function withStartValue(startValue, animation) {
-    'worklet';
-    return defineAnimation(startValue, () => {
-        'worklet';
-        if (!_WORKLET && typeof animation === 'function') {
-            animation = animation();
-        }
-        animation.current = startValue;
-        return animation;
-    });
-}

package/lib/reanimated2/commonTypes.js

@@ -1,8 +0,0 @@
-export var KeyboardState;
-(function (KeyboardState) {
-    KeyboardState[KeyboardState["UNKNOWN"] = 0] = "UNKNOWN";
-    KeyboardState[KeyboardState["OPENING"] = 1] = "OPENING";
-    KeyboardState[KeyboardState["OPEN"] = 2] = "OPEN";
-    KeyboardState[KeyboardState["CLOSING"] = 3] = "CLOSING";
-    KeyboardState[KeyboardState["CLOSED"] = 4] = "CLOSED";
-})(KeyboardState || (KeyboardState = {}));

package/lib/reanimated2/component/FlatList.js

@@ -1,30 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import React, { forwardRef } from 'react';
-import { FlatList } from 'react-native';
-import ReanimatedView from './View';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedFlatList = createAnimatedComponent(FlatList);
-const createCellRenderer = (itemLayoutAnimation) => {
-    const cellRenderer = (props) => {
-        return (<ReanimatedView layout={itemLayoutAnimation} onLayout={props.onLayout}>
-        {props.children}
-      </ReanimatedView>);
-    };
-    return cellRenderer;
-};
-const ReanimatedFlatlist = forwardRef((props, ref) => {
-    const { itemLayoutAnimation } = props, restProps = __rest(props, ["itemLayoutAnimation"]);
-    const cellRenderer = React.useMemo(() => createCellRenderer(itemLayoutAnimation), []);
-    return (<AnimatedFlatList ref={ref} {...restProps} CellRendererComponent={cellRenderer}/>);
-});
-export default ReanimatedFlatlist;

package/lib/reanimated2/component/Image.js

@@ -1,4 +0,0 @@
-import { Image } from 'react-native';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedImage = createAnimatedComponent(Image);
-export default AnimatedImage;

package/lib/reanimated2/component/ScrollView.js

@@ -1,4 +0,0 @@
-import { ScrollView } from 'react-native';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedScrollView = createAnimatedComponent(ScrollView);
-export default AnimatedScrollView;

package/lib/reanimated2/component/Text.js

@@ -1,4 +0,0 @@
-import { Text } from 'react-native';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedText = createAnimatedComponent(Text);
-export default AnimatedText;

package/lib/reanimated2/component/View.js

@@ -1,4 +0,0 @@
-import { View } from 'react-native';
-import createAnimatedComponent from '../../createAnimatedComponent';
-const AnimatedView = createAnimatedComponent(View);
-export default AnimatedView;

package/lib/reanimated2/core.js

@@ -1,269 +0,0 @@
-/* global _WORKLET _getCurrentTime _frameTimestamp _eventTimestamp, _setGlobalConsole */
-import NativeReanimatedModule from './NativeReanimated';
-import { Platform } from 'react-native';
-import { nativeShouldBeMock, shouldBeUseWeb, isWeb } from './PlatformChecker';
-if (global._setGlobalConsole === undefined) {
-    // it can happen when Reanimated plugin wasn't added, but the user uses the only API from version 1
-    global._setGlobalConsole = () => {
-        // noop
-    };
-}
-const testWorklet = () => {
-    'worklet';
-};
-const throwUninitializedReanimatedException = () => {
-    throw new Error("Failed to initialize react-native-reanimated library, make sure you followed installation steps here: https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation/ \n1) Make sure reanimated's babel plugin is installed in your babel.config.js (you should have 'react-native-reanimated/plugin' listed there - also see the above link for details) \n2) Make sure you reset build cache after updating the config, run: yarn start --reset-cache");
-};
-export const checkPluginState = (throwError = true) => {
-    if (!testWorklet.__workletHash && !shouldBeUseWeb()) {
-        if (throwError) {
-            throwUninitializedReanimatedException();
-        }
-        return false;
-    }
-    return true;
-};
-export const isConfigured = (throwError = false) => {
-    return checkPluginState(throwError);
-};
-export const isConfiguredCheck = () => {
-    checkPluginState(true);
-};
-function pushFrame(frame) {
-    NativeReanimatedModule.pushFrame(frame);
-}
-export function requestFrame(frame) {
-    'worklet';
-    if (NativeReanimatedModule.native) {
-        requestAnimationFrame(frame);
-    }
-    else {
-        pushFrame(frame);
-    }
-}
-global._WORKLET = false;
-global._log = function (s) {
-    console.log(s);
-};
-export function runOnUI(worklet) {
-    return makeShareable(worklet);
-}
-export function makeShareable(value) {
-    isConfiguredCheck();
-    return NativeReanimatedModule.makeShareable(value);
-}
-export function getViewProp(viewTag, propName) {
-    return new Promise((resolve, reject) => {
-        return NativeReanimatedModule.getViewProp(viewTag, propName, (result) => {
-            if (typeof result === 'string' && result.substr(0, 6) === 'error:') {
-                reject(result);
-            }
-            else {
-                resolve(result);
-            }
-        });
-    });
-}
-let _getTimestamp;
-if (nativeShouldBeMock()) {
-    _getTimestamp = () => {
-        return NativeReanimatedModule.getTimestamp();
-    };
-}
-else {
-    _getTimestamp = () => {
-        'worklet';
-        if (_frameTimestamp) {
-            return _frameTimestamp;
-        }
-        if (_eventTimestamp) {
-            return _eventTimestamp;
-        }
-        return _getCurrentTime();
-    };
-}
-export function getTimestamp() {
-    'worklet';
-    if (Platform.OS === 'web') {
-        return NativeReanimatedModule.getTimestamp();
-    }
-    return _getTimestamp();
-}
-function workletValueSetter(value) {
-    'worklet';
-    const previousAnimation = this._animation;
-    if (previousAnimation) {
-        previousAnimation.cancelled = true;
-        this._animation = null;
-    }
-    if (typeof value === 'function' ||
-        (value !== null &&
-            typeof value === 'object' &&
-            value.onFrame !== undefined)) {
-        const animation = typeof value === 'function'
-            ? value()
-            : value;
-        // prevent setting again to the same value
-        // and triggering the mappers that treat this value as an input
-        // this happens when the animation's target value(stored in animation.current until animation.onStart is called) is set to the same value as a current one(this._value)
-        // built in animations that are not higher order(withTiming, withSpring) hold target value in .current
-        if (this._value === animation.current && !animation.isHigherOrder) {
-            animation.callback && animation.callback(true);
-            return;
-        }
-        // animated set
-        const initializeAnimation = (timestamp) => {
-            animation.onStart(animation, this.value, timestamp, previousAnimation);
-        };
-        initializeAnimation(getTimestamp());
-        const step = (timestamp) => {
-            if (animation.cancelled) {
-                animation.callback && animation.callback(false /* finished */);
-                return;
-            }
-            const finished = animation.onFrame(animation, timestamp);
-            animation.finished = true;
-            animation.timestamp = timestamp;
-            this._value = animation.current;
-            if (finished) {
-                animation.callback && animation.callback(true /* finished */);
-            }
-            else {
-                requestAnimationFrame(step);
-            }
-        };
-        this._animation = animation;
-        if (_frameTimestamp) {
-            // frame
-            step(_frameTimestamp);
-        }
-        else {
-            requestAnimationFrame(step);
-        }
-    }
-    else {
-        // prevent setting again to the same value
-        // and triggering the mappers that treat this value as an input
-        if (this._value === value) {
-            return;
-        }
-        this._value = value;
-    }
-}
-// We cannot use pushFrame
-// so we use own implementation for js
-function workletValueSetterJS(value) {
-    const previousAnimation = this._animation;
-    if (previousAnimation) {
-        previousAnimation.cancelled = true;
-        this._animation = null;
-    }
-    if (typeof value === 'function' ||
-        (value !== null &&
-            typeof value === 'object' &&
-            value.onFrame)) {
-        // animated set
-        const animation = typeof value === 'function'
-            ? value()
-            : value;
-        let initializeAnimation = (timestamp) => {
-            animation.onStart(animation, this.value, timestamp, previousAnimation);
-        };
-        const step = (timestamp) => {
-            if (animation.cancelled) {
-                animation.callback && animation.callback(false /* finished */);
-                return;
-            }
-            if (initializeAnimation) {
-                initializeAnimation(timestamp);
-                initializeAnimation = null; // prevent closure from keeping ref to previous animation
-            }
-            const finished = animation.onFrame(animation, timestamp);
-            animation.timestamp = timestamp;
-            this._setValue && this._setValue(animation.current);
-            if (finished) {
-                animation.callback && animation.callback(true /* finished */);
-            }
-            else {
-                requestFrame(step);
-            }
-        };
-        this._animation = animation;
-        requestFrame(step);
-    }
-    else {
-        this._setValue && this._setValue(value);
-    }
-}
-export function makeMutable(value) {
-    isConfiguredCheck();
-    return NativeReanimatedModule.makeMutable(value);
-}
-export function makeRemote(object = {}) {
-    isConfiguredCheck();
-    return NativeReanimatedModule.makeRemote(object);
-}
-export function startMapper(mapper, inputs = [], outputs = [], updater = () => {
-    // noop
-}, viewDescriptors = []) {
-    isConfiguredCheck();
-    return NativeReanimatedModule.startMapper(mapper, inputs, outputs, updater, viewDescriptors);
-}
-export function stopMapper(mapperId) {
-    NativeReanimatedModule.stopMapper(mapperId);
-}
-export function runOnJS(fun) {
-    'worklet';
-    if (!_WORKLET) {
-        return fun;
-    }
-    if (!fun.__callAsync) {
-        throw new Error("Attempting to call runOnJS with an object that is not a host function. Using runOnJS is only possible with methods that are defined on the main React-Native Javascript thread and that aren't marked as worklets");
-    }
-    else {
-        return fun.__callAsync;
-    }
-}
-NativeReanimatedModule.installCoreFunctions(NativeReanimatedModule.native
-    ? workletValueSetter
-    : workletValueSetterJS);
-if (!isWeb() && isConfigured()) {
-    const capturableConsole = console;
-    runOnUI(() => {
-        'worklet';
-        const console = {
-            debug: runOnJS(capturableConsole.debug),
-            log: runOnJS(capturableConsole.log),
-            warn: runOnJS(capturableConsole.warn),
-            error: runOnJS(capturableConsole.error),
-            info: runOnJS(capturableConsole.info),
-        };
-        _setGlobalConsole(console);
-    })();
-}
-let featuresConfig = {
-    enableLayoutAnimations: false,
-    setByUser: false,
-};
-export function enableLayoutAnimations(flag, isCallByUser = true) {
-    if (isCallByUser) {
-        featuresConfig = {
-            enableLayoutAnimations: flag,
-            setByUser: true,
-        };
-        NativeReanimatedModule.enableLayoutAnimations(flag);
-    }
-    else if (!featuresConfig.setByUser &&
-        featuresConfig.enableLayoutAnimations !== flag) {
-        featuresConfig.enableLayoutAnimations = flag;
-        NativeReanimatedModule.enableLayoutAnimations(flag);
-    }
-}
-export function configureProps(uiProps, nativeProps) {
-    if (!nativeShouldBeMock()) {
-        NativeReanimatedModule.configureProps(uiProps, nativeProps);
-    }
-}
-export function jestResetJsReanimatedModule() {
-    NativeReanimatedModule.jestResetModule();
-}

package/lib/reanimated2/frameCallback/FrameCallbackRegistryJS.js

@@ -1,32 +0,0 @@
-import { runOnUI } from '../core';
-import { prepareUIRegistry } from './FrameCallbackRegistryUI';
-export default class FrameCallbackRegistryJS {
-    constructor() {
-        this.nextCallbackId = 0;
-        prepareUIRegistry();
-    }
-    registerFrameCallback(callback) {
-        if (!callback) {
-            return -1;
-        }
-        const callbackId = this.nextCallbackId;
-        this.nextCallbackId++;
-        runOnUI(() => {
-            'worklet';
-            global._frameCallbackRegistry.registerFrameCallback(callback, callbackId);
-        })();
-        return callbackId;
-    }
-    unregisterFrameCallback(callbackId) {
-        runOnUI(() => {
-            'worklet';
-            global._frameCallbackRegistry.unregisterFrameCallback(callbackId);
-        })();
-    }
-    manageStateFrameCallback(callbackId, state) {
-        runOnUI(() => {
-            'worklet';
-            global._frameCallbackRegistry.manageStateFrameCallback(callbackId, state);
-        })();
-    }
-}

package/lib/reanimated2/frameCallback/FrameCallbackRegistryUI.js

@@ -1,76 +0,0 @@
-import { runOnUI } from '../core';
-export const prepareUIRegistry = runOnUI(() => {
-    'worklet';
-    const frameCallbackRegistry = {
-        frameCallbackRegistry: new Map(),
-        activeFrameCallbacks: new Set(),
-        previousFrameTimestamp: null,
-        runCallbacks() {
-            const loop = (timestamp) => {
-                if (this.previousFrameTimestamp === null) {
-                    this.previousFrameTimestamp = timestamp;
-                }
-                const delta = timestamp - this.previousFrameTimestamp;
-                this.activeFrameCallbacks.forEach((callbackId) => {
-                    const callbackDetails = this.frameCallbackRegistry.get(callbackId);
-                    const { startTime } = callbackDetails;
-                    if (startTime === null) {
-                        // First frame
-                        callbackDetails.startTime = timestamp;
-                        callbackDetails.callback({
-                            timestamp,
-                            timeSincePreviousFrame: null,
-                            timeSinceFirstFrame: 0,
-                        });
-                    }
-                    else {
-                        // Next frame
-                        callbackDetails.callback({
-                            timestamp,
-                            timeSincePreviousFrame: delta,
-                            timeSinceFirstFrame: timestamp - startTime,
-                        });
-                    }
-                });
-                if (this.activeFrameCallbacks.size > 0) {
-                    this.previousFrameTimestamp = timestamp;
-                    requestAnimationFrame(loop);
-                }
-                else {
-                    this.previousFrameTimestamp = null;
-                }
-            };
-            // runCallback() should only be called after registering a callback,
-            // so if there is only one active callback, then it means that there were
-            // zero previously and the loop isn't running yet.
-            if (this.activeFrameCallbacks.size === 1) {
-                requestAnimationFrame(loop);
-            }
-        },
-        registerFrameCallback(callback, callbackId) {
-            this.frameCallbackRegistry.set(callbackId, {
-                callback: callback,
-                startTime: null,
-            });
-        },
-        unregisterFrameCallback(callbackId) {
-            this.manageStateFrameCallback(callbackId, false);
-            this.frameCallbackRegistry.delete(callbackId);
-        },
-        manageStateFrameCallback(callbackId, state) {
-            if (callbackId === -1) {
-                return;
-            }
-            if (state) {
-                this.activeFrameCallbacks.add(callbackId);
-                this.runCallbacks();
-            }
-            else {
-                const callback = this.frameCallbackRegistry.get(callbackId);
-                callback.startTime = null;
-                this.activeFrameCallbacks.delete(callbackId);
-            }
-        },
-    };
-    global._frameCallbackRegistry = frameCallbackRegistry;
-});