react-native-reanimated 2.4.1 → 2.5.0

package/lib/reanimated1/derived/interpolate.js

@@ -128,15 +128,13 @@ export default function interpolate(value, config) {
   const right = extrapolateRight || extrapolate;
   let output = interpolateInternal(value, inputRange, outputRange);
 
-  if (left === Extrapolate.EXTEND) {
-  } else if (left === Extrapolate.CLAMP) {
+  if (left === Extrapolate.CLAMP) {
     output = cond(lessThan(value, inputRange[0]), outputRange[0], output);
   } else if (left === Extrapolate.IDENTITY) {
     output = cond(lessThan(value, inputRange[0]), value, output);
   }
 
-  if (right === Extrapolate.EXTEND) {
-  } else if (right === Extrapolate.CLAMP) {
+  if (right === Extrapolate.CLAMP) {
     output = cond(
       greaterThan(value, inputRange[inputRange.length - 1]),
       outputRange[outputRange.length - 1],

package/lib/reanimated2/Colors.js

@@ -31,7 +31,8 @@ function getMatchers() {
         cachedMatchers.hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));
         cachedMatchers.hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));
         cachedMatchers.hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
-        cachedMatchers.hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
+        cachedMatchers.hex4 =
+            /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
         cachedMatchers.hex6 = /^#([0-9a-fA-F]{6})$/;
         cachedMatchers.hex8 = /^#([0-9a-fA-F]{8})$/;
     }

package/lib/reanimated2/NativeReanimated/NativeReanimated.js

@@ -1,37 +1,50 @@
-const InnerNativeModule = global.__reanimatedModuleProxy;
+import { NativeModules } from 'react-native';
 export class NativeReanimated {
     constructor(native = true) {
+        if (global.__reanimatedModuleProxy === undefined) {
+            const { ReanimatedModule } = NativeModules;
+            ReanimatedModule === null || ReanimatedModule === void 0 ? void 0 : ReanimatedModule.installTurboModule();
+        }
+        this.InnerNativeModule = global.__reanimatedModuleProxy;
         this.native = native;
-        this.useOnlyV1 = InnerNativeModule === null;
     }
     installCoreFunctions(valueSetter) {
-        return InnerNativeModule.installCoreFunctions(valueSetter);
+        return this.InnerNativeModule.installCoreFunctions(valueSetter);
     }
     makeShareable(value) {
-        return InnerNativeModule.makeShareable(value);
+        return this.InnerNativeModule.makeShareable(value);
     }
     makeMutable(value) {
-        return InnerNativeModule.makeMutable(value);
+        return this.InnerNativeModule.makeMutable(value);
     }
     makeRemote(object = {}) {
-        return InnerNativeModule.makeRemote(object);
+        return this.InnerNativeModule.makeRemote(object);
+    }
+    registerSensor(sensorType, interval, sensorData) {
+        return this.InnerNativeModule.registerSensor(sensorType, interval, sensorData);
+    }
+    unregisterSensor(sensorId) {
+        return this.InnerNativeModule.unregisterSensor(sensorId);
     }
     startMapper(mapper, inputs = [], outputs = [], updater, viewDescriptors) {
-        return InnerNativeModule.startMapper(mapper, inputs, outputs, updater, viewDescriptors);
+        return this.InnerNativeModule.startMapper(mapper, inputs, outputs, updater, viewDescriptors);
     }
     stopMapper(mapperId) {
-        return InnerNativeModule.stopMapper(mapperId);
+        return this.InnerNativeModule.stopMapper(mapperId);
     }
     registerEventHandler(eventHash, eventHandler) {
-        return InnerNativeModule.registerEventHandler(eventHash, eventHandler);
+        return this.InnerNativeModule.registerEventHandler(eventHash, eventHandler);
     }
     unregisterEventHandler(id) {
-        return InnerNativeModule.unregisterEventHandler(id);
+        return this.InnerNativeModule.unregisterEventHandler(id);
     }
     getViewProp(viewTag, propName, callback) {
-        return InnerNativeModule.getViewProp(viewTag, propName, callback);
+        return this.InnerNativeModule.getViewProp(viewTag, propName, callback);
     }
     enableLayoutAnimations(flag) {
-        InnerNativeModule.enableLayoutAnimations(flag);
+        this.InnerNativeModule.enableLayoutAnimations(flag);
+    }
+    configureProps(uiProps, nativeProps) {
+        this.InnerNativeModule.configureProps(uiProps, nativeProps);
     }
 }

package/lib/reanimated2/NativeReanimated/index.js

@@ -1,6 +1,5 @@
 import reanimatedJS from '../js-reanimated';
 import { shouldBeUseWeb } from '../PlatformChecker';
-import { Platform } from 'react-native';
 import { NativeReanimated } from './NativeReanimated';
 let exportedModule;
 if (shouldBeUseWeb()) {
@@ -8,8 +7,5 @@ if (shouldBeUseWeb()) {
 }
 else {
     exportedModule = new NativeReanimated();
-    if (exportedModule.useOnlyV1 && Platform.OS === 'android') {
-        console.warn(`If you want to use Reanimated 2 then go through our installation steps https://docs.swmansion.com/react-native-reanimated/docs/installation`);
-    }
 }
 export default exportedModule;

package/lib/reanimated2/ViewDescriptorsSet.js

@@ -1,7 +1,7 @@
 import { useRef } from 'react';
 import { makeMutable } from './core';
-import { Platform } from 'react-native';
-const scheduleUpdates = Platform.OS === 'web' ? requestAnimationFrame : setImmediate;
+import { shouldBeUseWeb } from './PlatformChecker';
+const scheduleUpdates = shouldBeUseWeb() ? requestAnimationFrame : setImmediate;
 export function makeViewDescriptorsSet() {
     const ref = useRef(null);
     if (ref.current === null) {

package/lib/reanimated2/animation/styleAnimation.js

@@ -35,7 +35,8 @@ export function setPath(obj, path, value) {
         }
         currObj = currObj[keys[i]];
     }
-    currObj[keys[keys.length - 1]] = value;
+    currObj[keys[keys.length - 1]] =
+        value;
 }
 export function withStyleAnimation(styleAnimations) {
     'worklet';

package/lib/reanimated2/core.js

@@ -24,7 +24,7 @@ export const checkPluginState = (throwError = true) => {
     return true;
 };
 export const isConfigured = (throwError = false) => {
-    return checkPluginState(throwError) && !NativeReanimatedModule.useOnlyV1;
+    return checkPluginState(throwError);
 };
 export const isConfiguredCheck = () => {
     if (!isConfigured(true)) {
@@ -259,29 +259,27 @@ export function runOnJS(fun) {
         return fun.__callAsync;
     }
 }
-if (!NativeReanimatedModule.useOnlyV1) {
-    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);
-            if (global.performance == null) {
-                global.performance = {
-                    now: global._chronoNow,
-                };
-            }
-        })();
-    }
+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);
+        if (global.performance == null) {
+            global.performance = {
+                now: global._chronoNow,
+            }; // due to conflict with lib.dom.d.ts -> Performance
+        }
+    })();
 }
 let featuresConfig = {
     enableLayoutAnimations: false,
@@ -301,3 +299,11 @@ export function enableLayoutAnimations(flag, isCallByUser = true) {
         NativeReanimatedModule.enableLayoutAnimations(flag);
     }
 }
+export function configureProps(uiProps, nativeProps) {
+    if (!nativeShouldBeMock()) {
+        NativeReanimatedModule.configureProps(uiProps, nativeProps);
+    }
+}
+export function jestResetJsReanimatedModule() {
+    NativeReanimatedModule.jestResetModule();
+}

package/lib/reanimated2/globals.d.ts

@@ -27,6 +27,9 @@ declare global {
     animated: boolean
   ) => void;
   const _chronoNow: () => number;
+  const ReanimatedDataMock: {
+    now: () => number;
+  };
   namespace NodeJS {
     interface Global {
       __reanimatedWorkletInit: (worklet: WorkletFunction) => void;
@@ -50,6 +53,9 @@ declare global {
           yogaValues: unknown
         ): void;
       };
+      ReanimatedDataMock: {
+        now: () => number;
+      };
     }
   }
 }

package/lib/reanimated2/hook/index.js

@@ -6,3 +6,4 @@ export { useAnimatedReaction, } from './useAnimatedReaction';
 export { useAnimatedRef } from './useAnimatedRef';
 export { useAnimatedScrollHandler, } from './useAnimatedScrollHandler';
 export { useDerivedValue } from './useDerivedValue';
+export { useAnimatedSensor, SensorType } from './useAnimatedSensor';

package/lib/reanimated2/hook/useAnimatedSensor.js

@@ -0,0 +1,66 @@
+import { useEffect, useRef } from 'react';
+import { makeMutable } from '../core';
+import NativeReanimated from '../NativeReanimated';
+export var SensorType;
+(function (SensorType) {
+    SensorType[SensorType["ACCELEROMETER"] = 1] = "ACCELEROMETER";
+    SensorType[SensorType["GYROSCOPE"] = 2] = "GYROSCOPE";
+    SensorType[SensorType["GRAVITY"] = 3] = "GRAVITY";
+    SensorType[SensorType["MAGNETIC_FIELD"] = 4] = "MAGNETIC_FIELD";
+    SensorType[SensorType["ROTATION"] = 5] = "ROTATION";
+})(SensorType || (SensorType = {}));
+export function useAnimatedSensor(sensorType, userConfig) {
+    const ref = useRef({
+        sensor: null,
+        unregister: () => {
+            // NOOP
+        },
+        isAvailable: false,
+        config: {
+            interval: 0,
+        },
+    });
+    if (ref.current.sensor === null) {
+        ref.current.config = Object.assign({ interval: 10 }, userConfig);
+        let sensorData;
+        if (sensorType === SensorType.ROTATION) {
+            sensorData = {
+                qw: 0,
+                qx: 0,
+                qy: 0,
+                qz: 0,
+                yaw: 0,
+                pitch: 0,
+                roll: 0,
+            };
+        }
+        else {
+            sensorData = {
+                x: 0,
+                y: 0,
+                z: 0,
+            };
+        }
+        ref.current.sensor = makeMutable(sensorData);
+    }
+    useEffect(() => {
+        ref.current.config = Object.assign({ interval: 10 }, userConfig);
+        const id = NativeReanimated.registerSensor(sensorType, ref.current.config.interval, ref.current.sensor);
+        if (id !== -1) {
+            // if sensor is available
+            ref.current.unregister = () => NativeReanimated.unregisterSensor(id);
+            ref.current.isAvailable = true;
+        }
+        else {
+            // if sensor is unavailable
+            ref.current.unregister = () => {
+                // NOOP
+            };
+            ref.current.isAvailable = false;
+        }
+        return () => {
+            ref.current.unregister();
+        };
+    }, [sensorType, userConfig]);
+    return ref.current;
+}

package/lib/reanimated2/interpolation.js

@@ -66,7 +66,7 @@ function validateType(type) {
 }
 function internalInterpolate(x, narrowedInput, extrapolationConfig) {
     'worklet';
-    const { leftEdgeInput, rightEdgeInput, leftEdgeOutput, rightEdgeOutput, } = narrowedInput;
+    const { leftEdgeInput, rightEdgeInput, leftEdgeOutput, rightEdgeOutput } = narrowedInput;
     if (rightEdgeInput - leftEdgeInput === 0)
         return leftEdgeOutput;
     const progress = (x - leftEdgeInput) / (rightEdgeInput - leftEdgeInput);

package/lib/reanimated2/jestUtils.js

@@ -1,6 +1,6 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-nocheck
-const MockDate = require('mockdate');
+import { jestResetJsReanimatedModule } from './core';
 let config = {
     fps: 60,
 };
@@ -105,22 +105,26 @@ const compareStyle = (received, expectedStyle, config) => {
 };
 let frameTime = 1000 / config.fps;
 let requestAnimationFrameCopy;
+let currentTimestamp = 0;
 const requestAnimationFrame = (callback) => {
     setTimeout(callback, frameTime);
 };
 const beforeTest = () => {
+    jestResetJsReanimatedModule();
     requestAnimationFrameCopy = global.requestAnimationFrame;
     global.requestAnimationFrame = requestAnimationFrame;
-    MockDate.set(0);
+    global.ReanimatedDataMock = {
+        now: () => currentTimestamp,
+    };
+    currentTimestamp = 0;
     jest.useFakeTimers();
 };
 const afterTest = () => {
-    MockDate.reset();
     jest.useRealTimers();
     global.requestAnimationFrame = requestAnimationFrameCopy;
 };
 const tickTravel = () => {
-    MockDate.set(new Date(Date.now() + frameTime));
+    currentTimestamp += frameTime;
     jest.advanceTimersByTime(frameTime);
 };
 export const withReanimatedTimer = (animatonTest) => {
@@ -142,6 +146,7 @@ export const advanceAnimationByFrame = (count) => {
 };
 export const setUpTests = (userConfig = {}) => {
     const expect = require('expect');
+    require('setimmediate');
     frameTime = Math.round(1000 / config.fps);
     config = Object.assign(Object.assign({}, config), userConfig);
     expect.extend({

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

@@ -2,6 +2,7 @@ import MapperRegistry from './MapperRegistry';
 import Mapper from './Mapper';
 import MutableValue from './MutableValue';
 import { NativeReanimated } from '../NativeReanimated/NativeReanimated';
+import { isJest } from '../PlatformChecker';
 export default class JSReanimated extends NativeReanimated {
     constructor() {
         super(false);
@@ -9,8 +10,8 @@ export default class JSReanimated extends NativeReanimated {
         this._renderRequested = false;
         this._mapperRegistry = new MapperRegistry(this);
         this._frames = [];
-        if (process.env.JEST_WORKER_ID) {
-            this.timeProvider = { now: () => Date.now() };
+        if (isJest()) {
+            this.timeProvider = { now: () => global.ReanimatedDataMock.now() };
         }
         else {
             this.timeProvider = { now: () => window.performance.now() };
@@ -75,4 +76,24 @@ export default class JSReanimated extends NativeReanimated {
     enableLayoutAnimations() {
         console.warn('[Reanimated] enableLayoutAnimations is not available for WEB yet');
     }
+    registerSensor() {
+        console.warn('[Reanimated] useAnimatedSensor is not available on web yet.');
+        return -1;
+    }
+    unregisterSensor() {
+        // noop
+    }
+    jestResetModule() {
+        if (isJest()) {
+            /**
+             * If someone used timers to stop animation before the end,
+             * then _renderRequested was set as true
+             * and any new update from another test wasn't applied.
+             */
+            this._renderRequested = false;
+        }
+        else {
+            throw Error('This method can be only use in Jest testing.');
+        }
+    }
 }

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

@@ -73,6 +73,14 @@ export class ComplexAnimationBuilder extends BaseAnimationBuilder {
         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;

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

@@ -109,7 +109,8 @@ export class Keyframe {
             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] = [];
+                        parsedKeyframes[index.toString() + '_transform:' + transformProp] =
+                            [];
                     });
                 });
             }