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

package/android/src/main/java/com/swmansion/reanimated/keyboardObserver/ReanimatedKeyboardEventListener.java

@@ -0,0 +1,165 @@
+package com.swmansion.reanimated.keyboardObserver;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import android.widget.FrameLayout;
+import androidx.annotation.NonNull;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
+import androidx.core.view.WindowInsetsAnimationCompat;
+import androidx.core.view.WindowInsetsCompat;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.PixelUtil;
+import com.swmansion.reanimated.BuildConfig;
+import com.swmansion.reanimated.NativeProxy.KeyboardEventDataUpdater;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.List;
+
+public class ReanimatedKeyboardEventListener {
+  enum KeyboardState {
+    UNKNOWN(0),
+    OPENING(1),
+    OPEN(2),
+    CLOSING(3),
+    CLOSED(4);
+
+    private final int value;
+
+    KeyboardState(int value) {
+      this.value = value;
+    }
+
+    public int asInt() {
+      return value;
+    }
+  }
+
+  private final WeakReference<ReactApplicationContext> reactContext;
+  private int nextListenerId = 0;
+  private KeyboardState state;
+  private final HashMap<Integer, KeyboardEventDataUpdater> listeners = new HashMap<>();
+
+  public ReanimatedKeyboardEventListener(WeakReference<ReactApplicationContext> reactContext) {
+    this.reactContext = reactContext;
+  }
+
+  private View getRootView() {
+    return reactContext.get().getCurrentActivity().getWindow().getDecorView();
+  }
+
+  private void setupWindowInsets() {
+    View rootView = getRootView();
+    WindowCompat.setDecorFitsSystemWindows(
+        reactContext.get().getCurrentActivity().getWindow(), false);
+    ViewCompat.setOnApplyWindowInsetsListener(
+        rootView,
+        (v, insets) -> {
+          int paddingBottom = 0;
+          if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED && BuildConfig.REACT_NATIVE_VERSION < 70) {
+            paddingBottom = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom;
+          }
+          int paddingTop = insets.getInsets(WindowInsetsCompat.Type.systemBars()).top;
+          View content =
+              rootView.getRootView().findViewById(com.swmansion.reanimated.R.id.action_bar_root);
+
+          FrameLayout.LayoutParams params =
+              new FrameLayout.LayoutParams(
+                  FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
+          params.setMargins(0, paddingTop, 0, paddingBottom);
+          content.setLayoutParams(params);
+          return insets;
+        });
+  }
+
+  private void updateKeyboard(int keyboardHeight) {
+    for (KeyboardEventDataUpdater listener : listeners.values()) {
+      listener.keyboardEventDataUpdater(state.asInt(), keyboardHeight);
+    }
+  }
+
+  private class WindowInsetsCallback extends WindowInsetsAnimationCompat.Callback {
+    private int keyboardHeight = 0;
+
+    public WindowInsetsCallback() {
+      super(WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE);
+    }
+
+    @NonNull
+    @Override
+    public WindowInsetsAnimationCompat.BoundsCompat onStart(
+        @NonNull WindowInsetsAnimationCompat animation,
+        @NonNull WindowInsetsAnimationCompat.BoundsCompat bounds) {
+      state = keyboardHeight == 0 ? KeyboardState.OPENING : KeyboardState.CLOSING;
+      updateKeyboard(keyboardHeight);
+      return super.onStart(animation, bounds);
+    }
+
+    @NonNull
+    @Override
+    public WindowInsetsCompat onProgress(
+        @NonNull WindowInsetsCompat insets,
+        @NonNull List<WindowInsetsAnimationCompat> runningAnimations) {
+
+      keyboardHeight =
+          (int)
+              PixelUtil.toDIPFromPixel(
+                  Math.max(
+                      0,
+                      insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+                          - insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom));
+      updateKeyboard(keyboardHeight);
+      return insets;
+    }
+
+    @Override
+    public void onEnd(@NonNull WindowInsetsAnimationCompat animation) {
+      state = keyboardHeight == 0 ? KeyboardState.CLOSED : KeyboardState.OPEN;
+      updateKeyboard(keyboardHeight);
+    }
+  }
+
+  private void setUpCallbacks() {
+    View rootView = getRootView();
+    new Handler(Looper.getMainLooper()).post(this::setupWindowInsets);
+    ViewCompat.setWindowInsetsAnimationCallback(rootView, new WindowInsetsCallback());
+  }
+
+  public int subscribeForKeyboardEvents(KeyboardEventDataUpdater updater) {
+    int listenerId = nextListenerId++;
+    if (listeners.isEmpty()) {
+      setUpCallbacks();
+    }
+    listeners.put(listenerId, updater);
+    return listenerId;
+  }
+
+  private void bringBackWindowInsets() {
+    WindowCompat.setDecorFitsSystemWindows(
+        reactContext.get().getCurrentActivity().getWindow(), true);
+    ViewCompat.setOnApplyWindowInsetsListener(getRootView(), null);
+    ViewCompat.setWindowInsetsAnimationCallback(getRootView(), null);
+    View content =
+        getRootView().getRootView().findViewById(com.swmansion.reanimated.R.id.action_bar_root);
+
+    FrameLayout.LayoutParams params =
+        new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT);
+    params.setMargins(0, 0, 0, 0);
+    content.setLayoutParams(params);
+  }
+
+  private void removeCallbacks() {
+    View rootView = getRootView();
+    new Handler(Looper.getMainLooper()).post(this::bringBackWindowInsets);
+    ViewCompat.setWindowInsetsAnimationCallback(rootView, null);
+  }
+
+  public void unsubscribeFromKeyboardEvents(int listenerId) {
+    listeners.remove(listenerId);
+    if (listeners.isEmpty()) {
+      removeCallbacks();
+    }
+  }
+}

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

@@ -229,24 +229,27 @@ public class AnimationsManager implements ViewHierarchyObserver {
   }
 
   private void removeLeftovers() {
-    HashSet<Integer> roots = new HashSet<>();
-    // go through ready to remove from bottom to top
-    for (int tag : mToRemove) {
-      View view = mViewForTag.get(tag);
-      if (view == null) {
-        try {
-          view = mUIManager.resolveView(tag);
-          mViewForTag.put(tag, view);
-        } catch (IllegalViewOperationException ignored) {
-          continue;
+    // mToRemove may be null if onCatalystInstanceDestroy was called first
+    if (mToRemove != null) {
+      HashSet<Integer> roots = new HashSet<>();
+      // go through ready to remove from bottom to top
+      for (int tag : mToRemove) {
+        View view = mViewForTag.get(tag);
+        if (view == null) {
+          try {
+            view = mUIManager.resolveView(tag);
+            mViewForTag.put(tag, view);
+          } catch (IllegalViewOperationException ignored) {
+            continue;
+          }
         }
+        findRoot(view, roots);
       }
-      findRoot(view, roots);
-    }
-    for (int tag : roots) {
-      View view = mViewForTag.get(tag);
-      if (view != null) {
-        dfs(view, view, mToRemove);
+      for (int tag : roots) {
+        View view = mViewForTag.get(tag);
+        if (view != null) {
+          dfs(view, view, mToRemove);
+        }
       }
     }
   }

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

@@ -3,13 +3,14 @@ package com.swmansion.reanimated.layoutReanimation;
 import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.soloader.SoLoader;
 import com.swmansion.reanimated.ReanimatedModule;
 import java.lang.ref.WeakReference;
 import java.util.Map;
 
 public class LayoutAnimations {
   static {
-    System.loadLibrary("reanimated");
+    SoLoader.loadLibrary("reanimated");
   }
 
   @DoNotStrip

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensor.java

@@ -23,7 +23,11 @@ public class ReanimatedSensor {
     sensorManager =
         (SensorManager) reactContext.get().getSystemService(reactContext.get().SENSOR_SERVICE);
     this.sensorType = sensorType;
-    this.interval = interval;
+    if (interval == -1) {
+      this.interval = SensorManager.SENSOR_DELAY_UI;
+    } else {
+      this.interval = interval;
+    }
   }
 
   boolean initialize() {

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorType.java

@@ -3,7 +3,7 @@ package com.swmansion.reanimated.sensor;
 import android.hardware.Sensor;
 
 public enum ReanimatedSensorType {
-  ACCELEROMETER(Sensor.TYPE_ACCELEROMETER),
+  ACCELEROMETER(Sensor.TYPE_LINEAR_ACCELERATION),
   GYROSCOPE(Sensor.TYPE_GYROSCOPE),
   GRAVITY(Sensor.TYPE_GRAVITY),
   MAGNETIC_FIELD(Sensor.TYPE_MAGNETIC_FIELD),

package/android/src/paper/java/com/swmansion/reanimated/NativeProxy.java

@@ -0,0 +1,326 @@
+package com.swmansion.reanimated;
+
+import android.os.SystemClock;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.ReactApplication;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableNativeArray;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.facebook.soloader.SoLoader;
+import com.swmansion.common.GestureHandlerStateManager;
+import com.swmansion.reanimated.keyboardObserver.ReanimatedKeyboardEventListener;
+import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
+import com.swmansion.reanimated.layoutReanimation.LayoutAnimations;
+import com.swmansion.reanimated.layoutReanimation.NativeMethodsHolder;
+import com.swmansion.reanimated.sensor.ReanimatedSensorContainer;
+import com.swmansion.reanimated.sensor.ReanimatedSensorType;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class NativeProxy {
+
+  static {
+    SoLoader.loadLibrary("reanimated");
+  }
+
+  @DoNotStrip
+  public static class AnimationFrameCallback implements NodesManager.OnAnimationFrame {
+
+    @DoNotStrip private final HybridData mHybridData;
+
+    @DoNotStrip
+    private AnimationFrameCallback(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    @Override
+    public native void onAnimationFrame(double timestampMs);
+  }
+
+  @DoNotStrip
+  public static class EventHandler implements RCTEventEmitter {
+
+    @DoNotStrip private final HybridData mHybridData;
+    private UIManagerModule.CustomEventNamesResolver mCustomEventNamesResolver;
+
+    @DoNotStrip
+    private EventHandler(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    @Override
+    public void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event) {
+      String resolvedEventName = mCustomEventNamesResolver.resolveCustomEventName(eventName);
+      receiveEvent(targetTag + resolvedEventName, event);
+    }
+
+    public native void receiveEvent(String eventKey, @Nullable WritableMap event);
+
+    @Override
+    public void receiveTouches(
+        String eventName, WritableArray touches, WritableArray changedIndices) {
+      // not interested in processing touch events this way, we process raw events only
+    }
+  }
+
+  @DoNotStrip
+  public static class SensorSetter {
+
+    @DoNotStrip private final HybridData mHybridData;
+
+    @DoNotStrip
+    private SensorSetter(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    public native void sensorSetter(float[] value);
+  }
+
+  @DoNotStrip
+  public static class KeyboardEventDataUpdater {
+    @DoNotStrip private final HybridData mHybridData;
+
+    @DoNotStrip
+    private KeyboardEventDataUpdater(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    public native void keyboardEventDataUpdater(int keyboardState, int height);
+  }
+
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private final HybridData mHybridData;
+
+  private NodesManager mNodesManager;
+  private final WeakReference<ReactApplicationContext> mContext;
+  private Scheduler mScheduler = null;
+  private ReanimatedSensorContainer reanimatedSensorContainer;
+  private final GestureHandlerStateManager gestureHandlerStateManager;
+  private ReanimatedKeyboardEventListener reanimatedKeyboardEventListener;
+  private Long firstUptime = SystemClock.uptimeMillis();
+  private boolean slowAnimationsEnabled = false;
+
+  public NativeProxy(ReactApplicationContext context) {
+    CallInvokerHolderImpl holder =
+        (CallInvokerHolderImpl) context.getCatalystInstance().getJSCallInvokerHolder();
+    LayoutAnimations LayoutAnimations = new LayoutAnimations(context);
+    mScheduler = new Scheduler(context);
+
+    mHybridData =
+        initHybrid(
+            context.getJavaScriptContextHolder().get(),
+            holder,
+            mScheduler,
+            LayoutAnimations);
+    mContext = new WeakReference<>(context);
+    prepare(LayoutAnimations);
+    reanimatedSensorContainer = new ReanimatedSensorContainer(mContext);
+    reanimatedKeyboardEventListener = new ReanimatedKeyboardEventListener(mContext);
+    addDevMenuOption();
+
+    GestureHandlerStateManager tempHandlerStateManager;
+    try {
+      Class<NativeModule> gestureHandlerModuleClass =
+          (Class<NativeModule>)
+              Class.forName("com.swmansion.gesturehandler.react.RNGestureHandlerModule");
+      tempHandlerStateManager =
+          (GestureHandlerStateManager) context.getNativeModule(gestureHandlerModuleClass);
+    } catch (ClassCastException | ClassNotFoundException e) {
+      tempHandlerStateManager = null;
+    }
+    gestureHandlerStateManager = tempHandlerStateManager;
+  }
+
+  private native HybridData initHybrid(
+      long jsContext,
+      CallInvokerHolderImpl jsCallInvokerHolder,
+      Scheduler scheduler,
+      LayoutAnimations LayoutAnimations);
+
+  private native void installJSIBindings();
+
+  public native boolean isAnyHandlerWaitingForEvent(String eventName);
+
+  public native void performOperations();
+
+  public Scheduler getScheduler() {
+    return mScheduler;
+  }
+
+  private void toggleSlowAnimations() {
+    slowAnimationsEnabled = !slowAnimationsEnabled;
+    if (slowAnimationsEnabled) {
+      firstUptime = SystemClock.uptimeMillis();
+    }
+  }
+
+  private void addDevMenuOption() {
+    // In Expo, `ApplicationContext` is not an instance of `ReactApplication`
+    if (mContext.get().getApplicationContext() instanceof ReactApplication) {
+      final DevSupportManager devSupportManager =
+          ((ReactApplication) mContext.get().getApplicationContext())
+              .getReactNativeHost()
+              .getReactInstanceManager()
+              .getDevSupportManager();
+
+      devSupportManager.addCustomDevOption(
+          "Toggle slow animations (Reanimated)", this::toggleSlowAnimations);
+    }
+  }
+
+  @DoNotStrip
+  private void requestRender(AnimationFrameCallback callback) {
+    mNodesManager.postOnAnimation(callback);
+  }
+
+  @DoNotStrip
+  private void updateProps(int viewTag, Map<String, Object> props) {
+    mNodesManager.updateProps(viewTag, props);
+  }
+
+  @DoNotStrip
+  private void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
+    mNodesManager.synchronouslyUpdateUIProps(viewTag, uiProps);
+  }
+
+  @DoNotStrip
+  private String obtainProp(int viewTag, String propName) {
+    return mNodesManager.obtainProp(viewTag, propName);
+  }
+
+  @DoNotStrip
+  private void scrollTo(int viewTag, double x, double y, boolean animated) {
+    mNodesManager.scrollTo(viewTag, x, y, animated);
+  }
+
+  @DoNotStrip
+  private void setGestureState(int handlerTag, int newState) {
+    if (gestureHandlerStateManager != null) {
+      gestureHandlerStateManager.setGestureHandlerState(handlerTag, newState);
+    }
+  }
+
+  @DoNotStrip
+  private String getUptime() {
+    if (slowAnimationsEnabled) {
+      final long ANIMATIONS_DRAG_FACTOR = 10;
+      return Long.toString(
+          this.firstUptime
+              + (SystemClock.uptimeMillis() - this.firstUptime) / ANIMATIONS_DRAG_FACTOR);
+    } else {
+      return Long.toString(SystemClock.uptimeMillis());
+    }
+  }
+
+  @DoNotStrip
+  private float[] measure(int viewTag) {
+    return mNodesManager.measure(viewTag);
+  }
+
+  @DoNotStrip
+  private void configureProps(ReadableNativeArray uiProps, ReadableNativeArray nativeProps) {
+    Set<String> uiPropsSet = convertProps(uiProps);
+    Set<String> nativePropsSet = convertProps(nativeProps);
+    mNodesManager.configureProps(uiPropsSet, nativePropsSet);
+  }
+
+  private Set<String> convertProps(ReadableNativeArray props) {
+    Set<String> propsSet = new HashSet<>();
+    ArrayList<Object> propsList = props.toArrayList();
+    for (int i = 0; i < propsList.size(); i++) {
+      propsSet.add((String) propsList.get(i));
+    }
+    return propsSet;
+  }
+
+  @DoNotStrip
+  private void registerEventHandler(EventHandler handler) {
+    handler.mCustomEventNamesResolver = mNodesManager.getEventNameResolver();
+    mNodesManager.registerEventHandler(handler);
+  }
+
+  @DoNotStrip
+  private int registerSensor(int sensorType, int interval, SensorSetter setter) {
+    return reanimatedSensorContainer.registerSensor(
+        ReanimatedSensorType.getInstanceById(sensorType), interval, setter);
+  }
+
+  @DoNotStrip
+  private void unregisterSensor(int sensorId) {
+    reanimatedSensorContainer.unregisterSensor(sensorId);
+  }
+
+  @DoNotStrip
+  private int subscribeForKeyboardEvents(KeyboardEventDataUpdater keyboardEventDataUpdater) {
+    return reanimatedKeyboardEventListener.subscribeForKeyboardEvents(keyboardEventDataUpdater);
+  }
+
+  @DoNotStrip
+  private void unsubscribeFromKeyboardEvents(int listenerId) {
+    reanimatedKeyboardEventListener.unsubscribeFromKeyboardEvents(listenerId);
+  }
+
+  public void onCatalystInstanceDestroy() {
+    mScheduler.deactivate();
+    mHybridData.resetNative();
+  }
+
+  public void prepare(LayoutAnimations LayoutAnimations) {
+    if (Utils.isChromeDebugger) {
+      Log.w("[REANIMATED]", "You can not use LayoutAnimation with enabled Chrome Debugger");
+      return;
+    }
+    mNodesManager = mContext.get().getNativeModule(ReanimatedModule.class).getNodesManager();
+    installJSIBindings();
+    AnimationsManager animationsManager =
+        mContext
+            .get()
+            .getNativeModule(ReanimatedModule.class)
+            .getNodesManager()
+            .getAnimationsManager();
+
+    WeakReference<LayoutAnimations> weakLayoutAnimations = new WeakReference<>(LayoutAnimations);
+    animationsManager.setNativeMethods(
+        new NativeMethodsHolder() {
+          @Override
+          public void startAnimationForTag(int tag, String type, HashMap<String, Float> values) {
+            LayoutAnimations LayoutAnimations = weakLayoutAnimations.get();
+            if (LayoutAnimations != null) {
+              HashMap<String, String> preparedValues = new HashMap<>();
+              for (String key : values.keySet()) {
+                preparedValues.put(key, values.get(key).toString());
+              }
+              LayoutAnimations.startAnimationForTag(tag, type, preparedValues);
+            }
+          }
+
+          @Override
+          public void removeConfigForTag(int tag) {
+            LayoutAnimations LayoutAnimations = weakLayoutAnimations.get();
+            if (LayoutAnimations != null) {
+              LayoutAnimations.removeConfigForTag(tag);
+            }
+          }
+
+          @Override
+          public boolean isLayoutAnimationEnabled() {
+            return LayoutAnimations.isLayoutAnimationEnabled();
+          }
+        });
+  }
+}

package/android/src/paper/java/com/swmansion/reanimated/ReaCompatibility.java

@@ -0,0 +1,17 @@
+package com.swmansion.reanimated;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+
+class ReaCompatibility {
+    public ReaCompatibility(ReactApplicationContext reactApplicationContext) {
+
+    }
+    public void registerFabricEventListener(NodesManager nodeManager) {
+
+    }
+    public void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
+
+    }
+}

package/ios/Fabric/REAInitializerRCTFabricSurface.h

@@ -0,0 +1,12 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <RNReanimated/REAModule.h>
+#import <React/RCTFabricSurface.h>
+
+@interface REAInitializerRCTFabricSurface : RCTFabricSurface
+
+@property REAModule *reaModule;
+
+@end
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/Fabric/REAInitializerRCTFabricSurface.mm

@@ -0,0 +1,73 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTSurface.h>
+#import <React/RCTSurfaceView.h>
+#import <memory>
+
+#import <RNReanimated/REAInitializerRCTFabricSurface.h>
+#import <RNReanimated/REAModule.h>
+
+@implementation REAInitializerRCTFabricSurface {
+  std::shared_ptr<facebook::react::SurfaceHandler> _surfaceHandler;
+  int _tag;
+  RCTSurface *_surface;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _tag = -1;
+    _surface = [[RCTSurface alloc] init];
+    _surfaceHandler = std::make_shared<facebook::react::SurfaceHandler>("REASurface", _tag);
+  }
+  return self;
+}
+
+- (NSNumber *)rootViewTag
+{
+  return @(_tag);
+}
+
+- (NSInteger)rootTag
+{
+  return (NSInteger)_tag;
+}
+
+- (void)start
+{
+  // this is only needed method, the rest of them is just for prevent null pointer exceptions
+  [_reaModule installReanimatedUIManagerBindingAfterReload];
+}
+
+- (facebook::react::SurfaceHandler const &)surfaceHandler
+{
+  return *_surfaceHandler.get();
+}
+
+- (void)setMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
+{
+}
+
+- (void)setMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize viewportOffset:(CGPoint)viewportOffset
+{
+}
+
+- (void)stop
+{
+}
+
+- (CGSize)sizeThatFitsMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
+{
+  CGSize size{0, 0};
+  return size;
+}
+
+- (nonnull RCTSurfaceView *)view
+{
+  // This method should never be called.
+  react_native_assert(false);
+}
+
+@end
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/REAEventDispatcher.m

@@ -1,5 +1,4 @@
 #import <RNReanimated/REAEventDispatcher.h>
-#import <RNReanimated/REAModule.h>
 #import <React/RCTBridge+Private.h>
 #import <React/RCTDefines.h>