react-native-reanimated 2.4.1 → 2.7.0

package/ios/sensor/ReanimatedSensor.m

@@ -0,0 +1,217 @@
+#import <RNReanimated/ReanimatedSensor.h>
+
+#if __has_include(<CoreMotion/CoreMotion.h>)
+@implementation ReanimatedSensor
+
+- (instancetype)init:(ReanimatedSensorType)sensorType interval:(int)interval setter:(void (^)(double[]))setter
+{
+  self = [super init];
+  _sensorType = sensorType;
+  _interval = interval / 1000; // in seconds
+  _setter = setter;
+  _motionManager = [[CMMotionManager alloc] init];
+  return self;
+}
+
+- (bool)initialize
+{
+  if (_sensorType == ACCELEROMETER) {
+    return [self initializeAccelerometer];
+  } else if (_sensorType == GYROSCOPE) {
+    return [self initializeGyroscope];
+  } else if (_sensorType == GRAVITY) {
+    return [self initializeGravity];
+  } else if (_sensorType == MAGNETIC_FIELD) {
+    return [self initializeMagnetometer];
+  } else if (_sensorType == ROTATION_VECTOR) {
+    return [self initializeOrientation];
+  }
+
+  return false;
+}
+
+- (bool)initializeGyroscope
+{
+  if (![_motionManager isGyroAvailable]) {
+    return false;
+  }
+  [_motionManager setGyroUpdateInterval:_interval];
+  [_motionManager startGyroUpdates];
+  [_motionManager
+      startGyroUpdatesToQueue:[NSOperationQueue mainQueue]
+                  withHandler:^(CMGyroData *sensorData, NSError *error) {
+                    double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                    if (currentTime - self->_lastTimestamp < self->_interval) {
+                      return;
+                    }
+                    double data[] = {sensorData.rotationRate.x, sensorData.rotationRate.y, sensorData.rotationRate.z};
+                    self->_setter(data);
+                    self->_lastTimestamp = currentTime;
+                  }];
+
+  return true;
+}
+
+- (bool)initializeAccelerometer
+{
+  if (![_motionManager isAccelerometerAvailable]) {
+    return false;
+  }
+  [_motionManager setAccelerometerUpdateInterval:_interval];
+  [_motionManager startAccelerometerUpdates];
+  [_motionManager
+      startAccelerometerUpdatesToQueue:[NSOperationQueue mainQueue]
+                           withHandler:^(CMAccelerometerData *sensorData, NSError *error) {
+                             double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                             if (currentTime - self->_lastTimestamp < self->_interval) {
+                               return;
+                             }
+                             double data[] = {
+                                 sensorData.acceleration.x, sensorData.acceleration.y, sensorData.acceleration.z};
+                             self->_setter(data);
+                             self->_lastTimestamp = currentTime;
+                           }];
+
+  return true;
+}
+
+- (bool)initializeGravity
+{
+  if (![_motionManager isDeviceMotionAvailable]) {
+    return false;
+  }
+  [_motionManager setDeviceMotionUpdateInterval:_interval];
+  [_motionManager setShowsDeviceMovementDisplay:YES];
+  [_motionManager
+      startDeviceMotionUpdatesToQueue:[NSOperationQueue mainQueue]
+                          withHandler:^(CMDeviceMotion *sensorData, NSError *error) {
+                            double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                            if (currentTime - self->_lastTimestamp < self->_interval) {
+                              return;
+                            }
+                            double data[] = {sensorData.gravity.x, sensorData.gravity.y, sensorData.gravity.z};
+                            self->_setter(data);
+                            self->_lastTimestamp = currentTime;
+                          }];
+
+  return true;
+}
+
+- (bool)initializeMagnetometer
+{
+  if (![_motionManager isMagnetometerAvailable]) {
+    return false;
+  }
+  [_motionManager setMagnetometerUpdateInterval:_interval];
+  [_motionManager startMagnetometerUpdates];
+  [_motionManager
+      startMagnetometerUpdatesToQueue:[NSOperationQueue mainQueue]
+                          withHandler:^(CMMagnetometerData *sensorData, NSError *error) {
+                            double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                            if (currentTime - self->_lastTimestamp < self->_interval) {
+                              return;
+                            }
+                            double data[] = {
+                                sensorData.magneticField.x, sensorData.magneticField.y, sensorData.magneticField.z};
+                            self->_setter(data);
+                            self->_lastTimestamp = currentTime;
+                          }];
+
+  return true;
+}
+
+- (bool)initializeOrientation
+{
+  if (![_motionManager isDeviceMotionAvailable]) {
+    return false;
+  }
+  [_motionManager setDeviceMotionUpdateInterval:_interval];
+
+  [_motionManager setShowsDeviceMovementDisplay:YES];
+  [_motionManager startDeviceMotionUpdatesUsingReferenceFrame:CMAttitudeReferenceFrameXTrueNorthZVertical
+                                                      toQueue:[NSOperationQueue mainQueue]
+                                                  withHandler:^(CMDeviceMotion *sensorData, NSError *error) {
+                                                    double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                                                    if (currentTime - self->_lastTimestamp < self->_interval) {
+                                                      return;
+                                                    }
+                                                    CMAttitude *attitude = sensorData.attitude;
+                                                    double data[] = {
+                                                        attitude.quaternion.x,
+                                                        attitude.quaternion.y,
+                                                        attitude.quaternion.z,
+                                                        attitude.quaternion.w,
+                                                        attitude.pitch,
+                                                        attitude.roll,
+                                                        attitude.yaw,
+                                                    };
+                                                    self->_setter(data);
+                                                    self->_lastTimestamp = currentTime;
+                                                  }];
+
+  return true;
+}
+
+- (void)cancel
+{
+  if (_sensorType == ACCELEROMETER) {
+    [_motionManager stopAccelerometerUpdates];
+  } else if (_sensorType == GYROSCOPE) {
+    [_motionManager stopGyroUpdates];
+  } else if (_sensorType == GRAVITY) {
+    [_motionManager stopDeviceMotionUpdates];
+  } else if (_sensorType == MAGNETIC_FIELD) {
+    [_motionManager stopMagnetometerUpdates];
+  } else if (_sensorType == ROTATION_VECTOR) {
+    [_motionManager stopDeviceMotionUpdates];
+  }
+}
+
+@end
+
+#else
+
+@implementation ReanimatedSensor
+
+- (instancetype)init:(ReanimatedSensorType)sensorType interval:(int)interval setter:(void (^)(double[]))setter
+{
+  self = [super init];
+  return self;
+}
+
+- (bool)initialize
+{
+  return false;
+}
+
+- (bool)initializeGyroscope
+{
+  return false;
+}
+
+- (bool)initializeAccelerometer
+{
+  return false;
+}
+
+- (bool)initializeGravity
+{
+  return false;
+}
+
+- (bool)initializeMagnetometer
+{
+  return false;
+}
+
+- (bool)initializeOrientation
+{
+  return false;
+}
+
+- (void)cancel
+{
+}
+
+@end
+#endif

package/ios/sensor/ReanimatedSensorContainer.h

@@ -0,0 +1,12 @@
+#import <RNReanimated/ReanimatedSensorType.h>
+
+@interface ReanimatedSensorContainer : NSObject {
+  NSNumber *_nextSensorId;
+  NSMutableDictionary *_sensors;
+}
+
+- (instancetype)init;
+- (int)registerSensor:(ReanimatedSensorType)sensorType interval:(int)interval setter:(void (^)(double[]))setter;
+- (void)unregisterSensor:(int)sensorId;
+
+@end

package/ios/sensor/ReanimatedSensorContainer.m

@@ -0,0 +1,40 @@
+#import <Foundation/Foundation.h>
+#import <RNReanimated/ReanimatedSensor.h>
+#import <RNReanimated/ReanimatedSensorContainer.h>
+
+static NSNumber *_nextSensorId = nil;
+
+@implementation ReanimatedSensorContainer
+
+- (instancetype)init
+{
+  self = [super init];
+  _sensors = [[NSMutableDictionary alloc] init];
+  _nextSensorId = @0;
+  return self;
+}
+
+- (int)registerSensor:(ReanimatedSensorType)sensorType interval:(int)interval setter:(void (^)(double[]))setter
+{
+  ReanimatedSensor *sensor = [[ReanimatedSensor alloc] init:sensorType interval:interval setter:setter];
+  if ([sensor initialize]) {
+    NSNumber *sensorId = [_nextSensorId copy];
+    _nextSensorId = [NSNumber numberWithInt:[_nextSensorId intValue] + 1];
+    [_sensors setObject:sensor forKey:sensorId];
+    return [sensorId intValue];
+  } else {
+    return -1;
+  }
+}
+
+- (void)unregisterSensor:(int)sensorId
+{
+  NSNumber *_sensorId = [NSNumber numberWithInt:sensorId];
+  if (_sensors[_sensorId] == nil) {
+    return;
+  }
+  [_sensors[_sensorId] cancel];
+  [_sensors removeObjectForKey:_sensorId];
+}
+
+@end

package/ios/sensor/ReanimatedSensorType.h

@@ -0,0 +1,7 @@
+typedef NS_ENUM(NSUInteger, ReanimatedSensorType) {
+  ACCELEROMETER = 1,
+  GYROSCOPE = 2,
+  GRAVITY = 3,
+  MAGNETIC_FIELD = 4,
+  ROTATION_VECTOR = 5,
+};

package/lib/ConfigHelper.js

@@ -1,4 +1,4 @@
-import ReanimatedModule from './ReanimatedModule';
+import { configureProps as jsiConfigureProps } from './reanimated2/core';
 /**
  * Styles allowed to be direcly updated in UI thread
  */
@@ -76,7 +76,6 @@ let NATIVE_THREAD_PROPS_WHITELIST = {
     borderTopLeftRadius: true,
     borderTopRightRadius: true,
     borderTopStartRadius: true,
-    opacity: true,
     elevation: true,
     fontSize: true,
     lineHeight: true,
@@ -104,7 +103,7 @@ let NATIVE_THREAD_PROPS_WHITELIST = {
     placeholderTextColor: true,
 };
 function configureProps() {
-    ReanimatedModule.configureProps(Object.keys(NATIVE_THREAD_PROPS_WHITELIST), Object.keys(UI_THREAD_PROPS_WHITELIST));
+    jsiConfigureProps(Object.keys(UI_THREAD_PROPS_WHITELIST), Object.keys(NATIVE_THREAD_PROPS_WHITELIST));
 }
 export function addWhitelistedNativeProps(props) {
     const oldSize = Object.keys(NATIVE_THREAD_PROPS_WHITELIST).length;

package/lib/createAnimatedComponent.js

@@ -90,6 +90,7 @@ export default function createAnimatedComponent(Component, options) {
             this._viewTag = -1;
             this._isFirstRender = true;
             this.animatedStyle = { value: {} };
+            this.initialStyle = {};
             this._component = null;
             // The system is best designed when setNativeProps is implemented. It is
             // able to avoid re-rendering and directly set the attributes that changed.
@@ -438,11 +439,9 @@ export default function createAnimatedComponent(Component, options) {
                             // this is how we recognize styles returned by useAnimatedStyle
                             style.viewsRef.add(this);
                             if (this._isFirstRender) {
-                                return Object.assign(Object.assign({}, style.initial.value), initialUpdaterRun(style.initial.updater));
-                            }
-                            else {
-                                return style.initial.value;
+                                this.initialStyle = Object.assign(Object.assign({}, style.initial.value), initialUpdaterRun(style.initial.updater));
                             }
+                            return this.initialStyle;
                         }
                         else {
                             return style;

package/lib/reanimated1/core/AnimatedFunction.js

@@ -37,7 +37,7 @@ export function createAnimatedFunction(cb) {
   for (let i = 0; i < params.length; i++) {
     params[i] = createAnimatedParam();
   }
-  // eslint-disable-next-line standard/no-callback-literal
+  // eslint-disable-next-line node/no-callback-literal
   const what = cb(...params);
   const func = new AnimatedFunction(what, ...params);
   return (...args) => {

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/Easing.js

@@ -53,7 +53,10 @@ function cubic(t) {
  */
 function poly(n) {
     'worklet';
-    return (t) => Math.pow(t, n);
+    return (t) => {
+        'worklet';
+        return Math.pow(t, n);
+    };
 }
 /**
  * A sinusoidal function.
@@ -110,7 +113,10 @@ function elastic(bounciness = 1) {
  */
 function back(s = 1.70158) {
     'worklet';
-    return (t) => t * t * ((s + 1) * t - s);
+    return (t) => {
+        'worklet';
+        return t * t * ((s + 1) * t - s);
+    };
 }
 /**
  * Provides a simple bouncing effect.
@@ -224,7 +230,7 @@ function createChecker(worklet, workletName, prevArgs) {
         }
         // @ts-ignore this is implicitly any - TODO
         const res = worklet.apply(this, arguments);
-        if (!_WORKLET && res && typeof res === 'function' && res.__worklet) {
+        if (!_WORKLET && res && typeof res === 'function' && res.__workletHash) {
             return createChecker(res, workletName, arguments);
         }
         return res;

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

@@ -2,9 +2,6 @@
 import NativeReanimatedModule from './NativeReanimated';
 import { Platform } from 'react-native';
 import { nativeShouldBeMock, shouldBeUseWeb, isWeb } from './PlatformChecker';
-global.__reanimatedWorkletInit = function (worklet) {
-    worklet.__worklet = true;
-};
 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 = () => {
@@ -24,46 +21,13 @@ 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)) {
         throw new Error('If you want to use Reanimated 2 then go through our installation steps https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation');
     }
 };
-function _toArrayReanimated(object) {
-    'worklet';
-    if (Array.isArray(object)) {
-        return object;
-    }
-    if (typeof Symbol !== 'undefined' &&
-        (typeof Symbol === 'function' ? Symbol.iterator : '@@iterator') in
-            Object(object)) {
-        return Array.from(object);
-    }
-    throw new Error('Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.');
-}
-function _mergeObjectsReanimated() {
-    'worklet';
-    // we can't use rest parameters in worklets at the moment
-    // eslint-disable-next-line prefer-rest-params
-    const arr = Array.from(arguments);
-    return Object.assign.apply(null, [arr[0], ...arr.slice(1)]);
-}
-global.__reanimatedWorkletInit = function (worklet) {
-    worklet.__worklet = true;
-    if (worklet._closure) {
-        const closure = worklet._closure;
-        Object.keys(closure).forEach((key) => {
-            if (key === '_toConsumableArray') {
-                closure[key] = _toArrayReanimated;
-            }
-            if (key === '_objectSpread') {
-                closure[key] = _mergeObjectsReanimated;
-            }
-        });
-    }
-};
 function pushFrame(frame) {
     NativeReanimatedModule.pushFrame(frame);
 }
@@ -259,29 +223,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 +263,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

@@ -1,4 +1,4 @@
-import { AnimatedStyle, StyleProps, WorkletFunction } from './commonTypes';
+import { AnimatedStyle, StyleProps } from './commonTypes';
 import { ReanimatedConsole } from './core';
 import { MeasuredDimensions } from './NativeMethods';
 import { NativeReanimated } from './NativeReanimated/NativeReanimated';
@@ -27,9 +27,11 @@ declare global {
     animated: boolean
   ) => void;
   const _chronoNow: () => number;
+  const ReanimatedDataMock: {
+    now: () => number;
+  };
   namespace NodeJS {
     interface Global {
-      __reanimatedWorkletInit: (worklet: WorkletFunction) => void;
       _setGlobalConsole: (console?: ReanimatedConsole) => void;
       _log: (s: string) => void;
       _setGestureState: () => void;
@@ -50,6 +52,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';