react-native-reanimated 2.11.0 → 2.13.0

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -3,6 +3,7 @@
 #include <memory>
 #include <thread>
 #include <unordered_map>
+#include <utility>
 
 #include "EventHandlerRegistry.h"
 #include "FeaturesConfig.h"

package/RNReanimated.podspec

@@ -4,6 +4,7 @@ require_relative './scripts/reanimated_utils'
 reanimated_package_json = JSON.parse(File.read(File.join(__dir__, "package.json")))
 config = find_config()
 assert_no_multiple_instances(config)
+assert_no_reanimated2_with_new_architecture(reanimated_package_json)
 
 folly_prefix = config[:react_native_minor_version] >= 64 ? 'RCT-' : ''
 folly_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32 -DREACT_NATIVE_MINOR_VERSION=' + config[:react_native_minor_version].to_s
@@ -34,14 +35,16 @@ Pod::Spec.new do |s|
     "Common/cpp/hidden_headers/**"
   ]
 
-  s.pod_target_xcconfig    = {
+  s.pod_target_xcconfig = {
     "USE_HEADERMAP" => "YES",
-    "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ReactCommon\" \"$(PODS_TARGET_SRCROOT)\" \"$(PODS_ROOT)/#{folly_prefix}Folly\" \"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/boost-for-react-native\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/Headers/Private/React-Core\" "
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ReactCommon\" \"$(PODS_TARGET_SRCROOT)\" \"$(PODS_ROOT)/#{folly_prefix}Folly\" \"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/boost-for-react-native\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/Headers/Private/React-Core\" ",
+    "FRAMEWORK_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}/React-hermes\"",
   }
   s.compiler_flags = folly_compiler_flags + ' ' + boost_compiler_flags
   s.xcconfig               = {
-    "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/boost-for-react-native\" \"$(PODS_ROOT)/glog\" \"$(PODS_ROOT)/#{folly_prefix}Folly\" \"$(PODS_ROOT)/RCT-Folly\" \"${PODS_ROOT}/Headers/Public/React-hermes\" \"${PODS_ROOT}/Headers/Public/hermes-engine\" \"#{config[:react_native_common_dir]}\"",
-                               "OTHER_CFLAGS" => "$(inherited)" + " " + folly_flags }
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/boost-for-react-native\" \"$(PODS_ROOT)/glog\" \"$(PODS_ROOT)/#{folly_prefix}Folly\" \"$(PODS_ROOT)/RCT-Folly\" \"${PODS_ROOT}/Headers/Public/React-hermes\" \"${PODS_ROOT}/Headers/Public/hermes-engine\" \"$(PODS_ROOT)/#{config[:react_native_common_dir]}\"",
+    "OTHER_CFLAGS" => "$(inherited)" + " " + folly_flags 
+  }
 
   s.requires_arc = true
 

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +1,2 @@
-#Thu Oct 13 15:02:41 UTC 2022
+#Fri Nov 11 10:24:13 UTC 2022
 gradle.version=7.5.1

package/android/CMakeLists.txt

@@ -318,4 +318,4 @@ endif()
 set (ignoreMe "${CLIENT_SIDE_BUILD}")
 set (ignoreMe "${JS_RUNTIME_DIR}")
 set (ignoreMe "${PLAYGROUND_APP_NAME}")
-set (ignoreMe "${HERMES_ENABLE_DEBUGGER}")
+set (ignoreMe "${REANIMATED_PACKAGE_BUILD}")

package/android/build.gradle

@@ -1,6 +1,7 @@
 import com.android.Version
 import org.apache.tools.ant.filters.ReplaceTokens
-
+import org.apache.tools.ant.taskdefs.condition.Os
+import groovy.json.JsonSlurper
 import java.nio.file.Paths
 
 /**
@@ -43,12 +44,10 @@ def safeExtGet(prop, fallback) {
 }
 
 def safeAppExtGet(prop, fallback) {
-    def appProject = null
-    try {
-        appProject = project(":app")
-    } catch(Exception e) {
+    if (findProject(':app') == null) {
         return fallback
     }
+    def appProject = project(':app')
     appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
 }
 
@@ -150,7 +149,7 @@ def findReanimatedInstancesForPath(String path) {
     }.files
 }
 
-def assertNoMultipleInstances() {
+def checkNoMultipleInstances() {
     // Assert there are no multiple installations of Reanimated
     Set<File> files
     if (projectDir.path.contains(rootDir.parent)) {
@@ -167,9 +166,9 @@ def assertNoMultipleInstances() {
         String parsedLocation = files.stream().map({
             File file -> "- " + file.toString().replace("/package.json", "")
         }).collect().join("\n")
-        String exceptionMessage = "\nMultiple versions of Reanimated were detected. Only one " +
-            "instance of react-native-reanimated can be installed in a project. You need to " +
-            "resolve the conflict manually. Check out the documentation: " +
+        String exceptionMessage = "\n[react-native-reanimated] Multiple versions of Reanimated " +
+            "were detected. Only one instance of react-native-reanimated can be installed in a " +
+            "project. You need to resolve the conflict manually. Check out the documentation: " +
             "https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/" +
             "troubleshooting#multiple-versions-of-reanimated-were-detected \n\nConflict " +
             "between: \n" + parsedLocation + "\n";
@@ -177,6 +176,21 @@ def assertNoMultipleInstances() {
     }
 }
 
+def getReanimatedVersion() {
+    def inputFile = file(projectDir.path + '/../package.json')
+    def json = new JsonSlurper().parseText(inputFile.text)
+    String reanimatedVersion = json.version
+    def (major, minor, patch) = reanimatedVersion.tokenize('.')
+    return major.toInteger()
+}
+
+def toPlatformFileString(String path) {
+  if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+      path = path.replace(File.separatorChar, '/' as char)
+  }
+  return path
+}
+
 boolean CLIENT_SIDE_BUILD = resolveClientSideBuild()
 if (CLIENT_SIDE_BUILD) {
     configurations.maybeCreate("default")
@@ -195,6 +209,7 @@ def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
 def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
 def FBJNI_VERSION = "0.3.0"
 def REANIMATED_PACKAGE_BUILD = System.getenv("REANIMATED_PACKAGE_BUILD")
+def REANIMATED_MAJOR_VERSION = getReanimatedVersion()
 
 // We download various C++ open-source dependencies into downloads.
 // We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
@@ -440,7 +455,7 @@ android {
                         "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                         "-DANDROID_TOOLCHAIN=clang",
                         "-DBOOST_VERSION=${BOOST_VERSION}",
-                        "-DREACT_NATIVE_DIR=${reactNativeRootDir.path}",
+                        "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
                         "-DJS_RUNTIME=${JS_RUNTIME}",
                         "-DJS_RUNTIME_DIR=${jsRuntimeDir}",
                         "-DCLIENT_SIDE_BUILD=${CLIENT_SIDE_BUILD}",
@@ -525,27 +540,57 @@ android {
     sourceSets.main {
         java {
             if (isNewArchitectureEnabled()) {
-                srcDirs += [
-                        "src/fabric/java",
-                ]
+                srcDirs += "src/fabric/java"
             } else {
-                srcDirs += [
-                        "src/paper/java",
-                ]
+                srcDirs += "src/paper/java"
+            }
+
+            // messageQueueThread
+            if (REANIMATED_MAJOR_VERSION > 2) {
+                if (REACT_NATIVE_MINOR_VERSION <= 67) {
+                    srcDirs += "src/reactNativeVersionPatch/messageQueueThread/67"
+                } else {
+                    srcDirs += "src/reactNativeVersionPatch/messageQueueThread/latest"
+                }
+            }
+
+            // UIImplementation
+            if (REACT_NATIVE_MINOR_VERSION <= 64) {
+                srcDirs += "src/reactNativeVersionPatch/UIImplementation/64"
+            } else {
+                srcDirs += "src/reactNativeVersionPatch/UIImplementation/latest"
+            }
+
+            // nativeHierarchyManager
+            if (REACT_NATIVE_MINOR_VERSION <= 62) {
+                srcDirs += "src/reactNativeVersionPatch/nativeHierarchyManager/62"
+            } else {
+                srcDirs += "src/reactNativeVersionPatch/nativeHierarchyManager/latest"
             }
         }
     }
 }
 
-def assertionTask = task assertNoMultipleInstancesTask {
+def assertNoMultipleInstances = task assertNoMultipleInstancesTask {
     onlyIf { shouldAssertNoMultipleInstances() && CLIENT_SIDE_BUILD }
     doFirst {
-        assertNoMultipleInstances()
+        checkNoMultipleInstances()
+    }
+}
+
+def assertNoReanimated2WithNewArchitecture = task assertNoReanimated2WithNewArchitectureTask {
+    onlyIf { isNewArchitectureEnabled() && REANIMATED_MAJOR_VERSION == 2 }
+    doFirst {
+        throw new Exception(
+            "\n[react-native-reanimated] Reanimated 2.x does not support Fabric. " +
+            "Please upgrade to 3.x to use Reanimated with the New Architecture. " +
+            "For details, see https://blog.swmansion.com/announcing-reanimated-3-16167428c5f7"
+        )
     }
 }
 
 tasks.preBuild {
-    dependsOn assertionTask
+    dependsOn assertNoMultipleInstances, assertNoReanimated2WithNewArchitecture
 }
 
 task cleanCmakeCache() {
@@ -560,21 +605,7 @@ task printVersions {
     println "Gradle: ${project.gradle.gradleVersion}"
 }
 
-task Log {
-    println("building Reanimated2")
-}
-
-task applyJavaPatches(type: Copy) {
-    def patchDirectory = file("${projectDir}/rnVersionPatch/${REACT_NATIVE_MINOR_VERSION}")
-    if (patchDirectory.exists()) {
-        from ("${patchDirectory}") {
-            include "**/*.java"
-        }
-        into ("${projectDir}/src/main/java/com/swmansion/reanimated")
-    }
-}
-
-task createNativeDepsDirectories(dependsOn: applyJavaPatches) {
+task createNativeDepsDirectories() {
     downloadsDir.mkdirs()
     thirdPartyNdkDir.mkdirs()
 }
@@ -967,8 +998,13 @@ task prepareThirdPartyNdkHeaders(dependsOn:[
 ) {}
 
 def nativeBuildDependsOn(dependsOnTask) {
-    def buildTasks = tasks.findAll({ task ->
-        !task.name.contains("Clean") && (task.name.contains("externalNative") || task.name.contains("CMake")) })
+    def buildTasks = tasks.findAll({ task -> (
+        !task.name.contains("Clean")
+        && (task.name.contains("externalNative")
+            || task.name.contains("CMake")
+            || task.name.contains("generateJsonModel")
+        )
+    ) })
     buildTasks.forEach { task -> task.dependsOn(dependsOnTask) }
 }
 

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/ReanimatedUIManager.java

@@ -20,7 +20,7 @@ class ReaUiImplementationProvider extends UIImplementationProvider {
       ViewManagerRegistry viewManagerRegistry,
       EventDispatcher eventDispatcher,
       int minTimeLeftInFrameForNonBatchedOperationMs) {
-    return new ReanimatedUIImplementation(
+    return new com.facebook.react.uimanager.ReanimatedUIImplementation(
         reactContext,
         viewManagerRegistry,
         eventDispatcher,

package/android/src/reactNativeVersionPatch/messageQueueThread/67/com/swmansion/reanimated/ReanimatedMessageQueueThread.java

@@ -0,0 +1,12 @@
+package com.swmansion.reanimated;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.swmansion.reanimated.ReanimatedMessageQueueThreadBase;
+
+@DoNotStrip
+public class ReanimatedMessageQueueThread extends ReanimatedMessageQueueThreadBase {
+  @Override
+  public void runOnQueue(Runnable runnable) {
+    messageQueueThread.runOnQueue(runnable);
+  }
+}

package/android/src/reactNativeVersionPatch/messageQueueThread/latest/com/swmansion/reanimated/ReanimatedMessageQueueThread.java

@@ -0,0 +1,12 @@
+package com.swmansion.reanimated;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.swmansion.reanimated.ReanimatedMessageQueueThreadBase;
+
+@DoNotStrip
+public class ReanimatedMessageQueueThread extends ReanimatedMessageQueueThreadBase {
+  @Override
+  public boolean runOnQueue(Runnable runnable) {
+    return messageQueueThread.runOnQueue(runnable);
+  }
+}

package/ios/REAModule.mm

@@ -2,8 +2,7 @@
 #import <RNReanimated/REAModule.h>
 #import <RNReanimated/REANodesManager.h>
 #import <RNReanimated/REATransitionManager.h>
-
-#import "SingleInstanceChecker.h"
+#import <RNReanimated/SingleInstanceChecker.h>
 
 using namespace reanimated;
 
@@ -15,14 +14,17 @@ typedef void (^AnimatedOperation)(REANodesManager *nodesManager);
 #ifdef DEBUG
   SingleInstanceChecker<REAModule> singleInstanceChecker_;
 #endif
+  bool hasListeners;
 }
 
 RCT_EXPORT_MODULE(ReanimatedModule);
 
+#ifdef RCT_NEW_ARCH_ENABLED
 + (BOOL)requiresMainQueueSetup
 {
   return YES;
 }
+#endif // RCT_NEW_ARCH_ENABLED
 
 - (void)invalidate
 {
@@ -193,4 +195,21 @@ RCT_EXPORT_METHOD(triggerRender)
   [_nodesManager dispatchEvent:event];
 }
 
+- (void)startObserving
+{
+  hasListeners = YES;
+}
+
+- (void)stopObserving
+{
+  hasListeners = NO;
+}
+
+- (void)sendEventWithName:(NSString *)eventName body:(id)body
+{
+  if (hasListeners) {
+    [super sendEventWithName:eventName body:body];
+  }
+}
+
 @end

package/ios/keyboardObserver/REAKeyboardEventObserver.m

@@ -1,5 +1,5 @@
-#import "REAKeyboardEventObserver.h"
 #import <Foundation/Foundation.h>
+#import <RNReanimated/REAKeyboardEventObserver.h>
 #import <React/RCTDefines.h>
 #import <React/RCTUIManager.h>
 

package/lib/createAnimatedComponent.js

@@ -119,11 +119,10 @@ export default function createAnimatedComponent(Component, options) {
                 setLocalRef: (ref) => {
                     // TODO update config
                     const tag = findNodeHandle(ref);
-                    if ((this.props.layout || this.props.entering || this.props.exiting) &&
+                    if (!shouldBeUseWeb() &&
+                        (this.props.layout || this.props.entering || this.props.exiting) &&
                         tag != null) {
-                        if (!shouldBeUseWeb()) {
-                            enableLayoutAnimations(true, false);
-                        }
+                        enableLayoutAnimations(true, false);
                         let layout = this.props.layout ? this.props.layout : DefaultLayout;
                         let entering = this.props.entering
                             ? this.props.entering

package/lib/reanimated2/NativeMethods.js

@@ -1,53 +1,88 @@
 import { findNodeHandle } from 'react-native';
-import { shouldBeUseWeb } from './PlatformChecker';
+import { isChromeDebugger, isWeb, shouldBeUseWeb } from './PlatformChecker';
 export function getTag(view) {
     return findNodeHandle(view);
 }
 const isNative = !shouldBeUseWeb();
-export function measure(animatedRef) {
-    'worklet';
-    if (!isNative) {
-        console.warn('[Reanimated] measure() cannot be used on web or Chrome Debugger');
-        return null;
-    }
-    if (!_WORKLET) {
-        console.warn('[Reanimated] measure() was called from the main JS context. Measure is ' +
-            'only available in the UI runtime. This may also happen if measure() ' +
-            'was called by a worklet in the useAnimatedStyle hook, because useAnimatedStyle ' +
-            'calls the given worklet on the JS runtime during render. If you want to ' +
-            'prevent this warning then wrap the call with `if (_WORKLET)`. Then it will ' +
-            'only be called on the UI runtime after the render has been completed.');
-        return null;
-    }
-    const viewTag = animatedRef();
-    if (viewTag === -1) {
-        console.warn(`[Reanimated] The view with tag ${viewTag} is not a valid argument for measure(). This may be because the view is not currently rendered, which may not be a bug (e.g. an off-screen FlatList item).`);
-        return null;
-    }
-    const measured = _measure(viewTag);
-    if (measured === null) {
-        console.warn(`[Reanimated] The view with tag ${viewTag} has some undefined, not-yet-computed or meaningless value of \`LayoutMetrics\` type. This may be because the view is not currently rendered, which may not be a bug (e.g. an off-screen FlatList item).`);
-        return null;
-    }
-    else if (measured.x === -1234567) {
-        console.warn(`[Reanimated] The view with tag ${viewTag} returned an invalid measurement response`);
-        return null;
-    }
-    else if (isNaN(measured.x)) {
-        console.warn(`[Reanimated] The view with tag ${viewTag} gets view-flattened on Android. To disable view-flattening, set \`collapsable={false}\` on this component.`);
+export let measure;
+if (isWeb()) {
+    measure = (animatedRef) => {
+        const element = animatedRef(); // TODO: fix typing of animated refs on web
+        const viewportOffset = element.getBoundingClientRect();
+        return {
+            width: element.offsetWidth,
+            height: element.offsetHeight,
+            x: element.offsetLeft,
+            y: element.offsetTop,
+            pageX: viewportOffset.left,
+            pageY: viewportOffset.top,
+        };
+    };
+}
+else if (isChromeDebugger()) {
+    measure = (_animatedRef) => {
+        console.warn('[Reanimated] measure() cannot be used with Chrome Debugger.');
         return null;
-    }
-    else {
-        return measured;
-    }
+    };
 }
-export function scrollTo(animatedRef, x, y, animated) {
-    'worklet';
-    if (!_WORKLET || !isNative) {
-        return;
-    }
-    const viewTag = animatedRef();
-    _scrollTo(viewTag, x, y, animated);
+else {
+    measure = (animatedRef) => {
+        'worklet';
+        if (!_WORKLET) {
+            console.warn('[Reanimated] measure() was called from the main JS context. Measure is ' +
+                'only available in the UI runtime. This may also happen if measure() ' +
+                'was called by a worklet in the useAnimatedStyle hook, because useAnimatedStyle ' +
+                'calls the given worklet on the JS runtime during render. If you want to ' +
+                'prevent this warning then wrap the call with `if (_WORKLET)`. Then it will ' +
+                'only be called on the UI runtime after the render has been completed.');
+            return null;
+        }
+        const viewTag = animatedRef();
+        if (viewTag === -1) {
+            console.warn(`[Reanimated] The view with tag ${viewTag} is not a valid argument for measure(). This may be because the view is not currently rendered, which may not be a bug (e.g. an off-screen FlatList item).`);
+            return null;
+        }
+        const measured = _measure(viewTag);
+        if (measured === null) {
+            console.warn(`[Reanimated] The view with tag ${viewTag} has some undefined, not-yet-computed or meaningless value of \`LayoutMetrics\` type. This may be because the view is not currently rendered, which may not be a bug (e.g. an off-screen FlatList item).`);
+            return null;
+        }
+        else if (measured.x === -1234567) {
+            console.warn(`[Reanimated] The view with tag ${viewTag} returned an invalid measurement response.`);
+            return null;
+        }
+        else if (isNaN(measured.x)) {
+            console.warn(`[Reanimated] The view with tag ${viewTag} gets view-flattened on Android. To disable view-flattening, set \`collapsable={false}\` on this component.`);
+            return null;
+        }
+        else {
+            return measured;
+        }
+    };
+}
+export let scrollTo;
+if (isWeb()) {
+    scrollTo = (animatedRef, x, y, animated) => {
+        'worklet';
+        const element = animatedRef();
+        // @ts-ignore same call as in react-native-web
+        element.scrollTo({ x, y, animated });
+    };
+}
+else if (isNative) {
+    scrollTo = (animatedRef, x, y, animated) => {
+        'worklet';
+        if (!_WORKLET) {
+            return;
+        }
+        const viewTag = animatedRef();
+        _scrollTo(viewTag, x, y, animated);
+    };
+}
+else {
+    scrollTo = (_animatedRef, _x, _y) => {
+        // no-op
+    };
 }
 export function setGestureState(handlerTag, newState) {
     'worklet';

package/lib/reanimated2/globals.d.ts

@@ -1,13 +1,19 @@
-import { AnimatedStyle, StyleProps } from './commonTypes';
-import { ReanimatedConsole } from './core';
-import FrameCallbackRegistryUI from './frameCallback/FrameCallbackRegistryUI';
-import { MeasuredDimensions } from './NativeMethods';
-import { NativeReanimated } from './NativeReanimated/NativeReanimated';
+import type {
+  AnimatedStyle,
+  StyleProps,
+  MeasuredDimensions,
+} from './commonTypes';
+import type { ReanimatedConsole } from './core';
+import type { NativeReanimated } from './NativeReanimated/NativeReanimated';
+import type { FrameCallbackRegistryUI } from './frameCallback/FrameCallbackRegistryUI';
+
 declare global {
   const _WORKLET: boolean;
-  const _frameTimestamp: number;
+  const _frameTimestamp: number | null;
   const _eventTimestamp: number;
+  const __reanimatedModuleProxy: NativeReanimated;
   const _setGlobalConsole: (console?: ReanimatedConsole) => void;
+  const _log: (s: string) => void;
   const _getCurrentTime: () => number;
   const _stopObservingProgress: (tag: number, flag: boolean) => void;
   const _startObservingProgress: (
@@ -20,7 +26,7 @@ declare global {
     name: string,
     updates: StyleProps | AnimatedStyle
   ) => void;
-  const _measure: (viewTag: number) => MeasuredDimensions | null;
+  const _measure: (viewTag: number) => MeasuredDimensions;
   const _scrollTo: (
     viewTag: number,
     x: number,
@@ -28,20 +34,40 @@ declare global {
     animated: boolean
   ) => void;
   const _chronoNow: () => number;
+  const performance: { now: () => number };
+  const LayoutAnimationRepository: {
+    configs: Record<string, unknown>;
+    registerConfig(tag: number, config: Record<string, unknown>): void;
+    removeConfig(tag: number): void;
+    startAnimationForTag(tag: number, type: string, yogaValues: unknown): void;
+  };
   const ReanimatedDataMock: {
     now: () => number;
   };
   const _frameCallbackRegistry: FrameCallbackRegistryUI;
   namespace NodeJS {
     interface Global {
-      _setGlobalConsole: (console?: ReanimatedConsole) => void;
-      _log: (s: string) => void;
-      _setGestureState: () => void;
       _WORKLET: boolean;
-      __reanimatedModuleProxy: NativeReanimated;
+      _IS_FABRIC: boolean;
       _frameTimestamp: number | null;
-      _measure: () => MeasuredDimensions | null;
-      _scrollTo: () => void;
+      _eventTimestamp: number;
+      __reanimatedModuleProxy: NativeReanimated;
+      _setGlobalConsole: (console?: ReanimatedConsole) => void;
+      _log: (s: string) => void;
+      _getCurrentTime: () => number;
+      _stopObservingProgress: (tag: number, flag: boolean) => void;
+      _startObservingProgress: (
+        tag: number,
+        flag: { value: boolean; _value: boolean }
+      ) => void;
+      _setGestureState: (handlerTag: number, newState: number) => void;
+      _measure: (viewTag: number) => MeasuredDimensions;
+      _scrollTo: (
+        viewTag: number,
+        x: number,
+        y: number,
+        animated: boolean
+      ) => void;
       _chronoNow: () => number;
       performance: { now: () => number };
       LayoutAnimationRepository: {

package/lib/reanimated2/hook/useScrollViewOffset.js

@@ -1,6 +1,7 @@
 import { useEffect, useRef } from 'react';
 import { findNodeHandle } from 'react-native';
-import { useEvent, useSharedValue } from '.';
+import { useEvent } from './utils';
+import { useSharedValue } from './useSharedValue';
 const subscribeForEvents = [
     'onScroll',
     'onScrollBeginDrag',

package/lib/reanimated2/jestUtils.js

@@ -145,14 +145,21 @@ export const advanceAnimationByFrame = (count) => {
     jest.advanceTimersByTime(frameTime);
 };
 export const setUpTests = (userConfig = {}) => {
-    let expect;
-    try {
-        expect = require('expect');
-    }
-    catch (_) {
-        // for Jest in version 28+
-        const { expect: expectModule } = require('@jest/globals');
+    let expect = global.expect;
+    if (expect === undefined) {
+        const expectModule = require('expect');
         expect = expectModule;
+        // Starting from Jest 28, "expect" package uses named exports instead of default export.
+        // So, requiring "expect" package doesn't give direct access to "expect" function anymore.
+        // It gives access to the module object instead.
+        // We use this info to detect if the project uses Jest 28 or higher.
+        if (typeof expect === 'object') {
+            const jestGlobals = require('@jest/globals');
+            expect = jestGlobals.expect;
+        }
+        if (expect === undefined || expect.extend === undefined) {
+            expect = expectModule.default;
+        }
     }
     require('setimmediate');
     frameTime = Math.round(1000 / config.fps);