react-native-reanimated 3.8.0 → 3.9.0-layout-animation-experimental

package/android/src/reactNativeVersionPatch/RuntimeExecutor/latest/com/swmansion/reanimated/NativeProxy.java

@@ -0,0 +1,143 @@
+package com.swmansion.reanimated;
+
+import androidx.annotation.OptIn;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.RuntimeExecutor;
+import com.facebook.react.bridge.queue.MessageQueueThread;
+import com.facebook.react.common.annotations.FrameworkAPI;
+import com.facebook.react.fabric.FabricUIManager;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.common.UIManagerType;
+import com.swmansion.reanimated.layoutReanimation.LayoutAnimations;
+import com.swmansion.reanimated.layoutReanimation.NativeMethodsHolder;
+import com.swmansion.reanimated.nativeProxy.NativeProxyCommon;
+
+import java.util.HashMap;
+import java.util.Objects;
+
+public class NativeProxy extends NativeProxyCommon {
+    @DoNotStrip
+    @SuppressWarnings("unused")
+    private final HybridData mHybridData;
+
+    public @OptIn(markerClass = FrameworkAPI.class) NativeProxy(ReactApplicationContext context, String valueUnpackerCode) {
+        super(context);
+        ReactFeatureFlagsWrapper.enableMountHooks();
+
+        FabricUIManager fabricUIManager =
+                (FabricUIManager) UIManagerHelper.getUIManager(context, UIManagerType.FABRIC);
+
+        LayoutAnimations LayoutAnimations = new LayoutAnimations(context);
+
+        ReanimatedMessageQueueThread messageQueueThread = new ReanimatedMessageQueueThread();
+
+
+        if (context.isBridgeless()) {
+            RuntimeExecutor runtimeExecutor = context.getRuntimeExecutor();
+            mHybridData = initHybridBridgeless(
+              Objects.requireNonNull(context.getJavaScriptContextHolder()).get(),
+              runtimeExecutor,
+              mAndroidUIScheduler,
+              LayoutAnimations,
+              messageQueueThread,
+              fabricUIManager,
+              valueUnpackerCode
+            );
+        } else {
+            CallInvokerHolderImpl callInvokerHolder = (CallInvokerHolderImpl) context.getCatalystInstance().getJSCallInvokerHolder();
+            mHybridData =
+              initHybrid(
+                Objects.requireNonNull(context.getJavaScriptContextHolder()).get(),
+                callInvokerHolder,
+                mAndroidUIScheduler,
+                LayoutAnimations,
+                messageQueueThread,
+                fabricUIManager,
+                valueUnpackerCode);
+        }
+        prepareLayoutAnimations(LayoutAnimations);
+        installJSIBindings();
+        if (BuildConfig.DEBUG) {
+            checkCppVersion();
+        }
+    }
+
+    private native HybridData initHybrid(
+            long jsContext,
+            CallInvokerHolderImpl jsCallInvokerHolder,
+            AndroidUIScheduler androidUIScheduler,
+            LayoutAnimations LayoutAnimations,
+            MessageQueueThread messageQueueThread,
+            FabricUIManager fabricUIManager,
+            String valueUnpackerCode);
+
+    private native HybridData initHybridBridgeless(
+      long jsContext,
+      RuntimeExecutor runtimeExecutor,
+      AndroidUIScheduler androidUIScheduler,
+      LayoutAnimations LayoutAnimations,
+      MessageQueueThread messageQueueThread,
+      FabricUIManager fabricUIManager,
+      String valueUnpackerCode);
+
+    public native boolean isAnyHandlerWaitingForEvent(String eventName, int emitterReactTag);
+
+    public native void performOperations();
+
+    @Override
+    protected HybridData getHybridData() {
+        return mHybridData;
+    }
+
+    public static NativeMethodsHolder createNativeMethodsHolder(LayoutAnimations layoutAnimations) {
+        return new NativeMethodsHolder() {
+            @Override
+            public void startAnimation(int tag, int type, HashMap<String, Object> values) {
+                // NOT IMPLEMENTED
+            }
+
+            @Override
+            public boolean isLayoutAnimationEnabled() {
+                // NOT IMPLEMENTED
+                return false;
+            }
+
+            @Override
+            public int findPrecedingViewTagForTransition(int tag) {
+                // NOT IMPLEMENTED
+                return -1;
+            }
+
+            @Override
+            public boolean shouldAnimateExiting(int tag, boolean shouldAnimate) {
+                // NOT IMPLEMENTED
+                return false;
+            }
+
+            @Override
+            public boolean hasAnimation(int tag, int type) {
+                // NOT IMPLEMENTED
+                return false;
+            }
+
+            @Override
+            public void clearAnimationConfig(int tag) {
+                // NOT IMPLEMENTED
+            }
+
+            @Override
+            public void cancelAnimation(int tag) {
+                // NOT IMPLEMENTED
+            }
+
+            @Override
+            public void checkDuplicateSharedTag(int viewTag, int screenTag) {
+                // NOT IMPLEMENTED
+            }
+        };
+    }
+}

package/apple/LayoutReanimation/REAAnimationsManager.h

@@ -20,6 +20,7 @@ typedef BOOL (^REAShouldAnimateExitingBlock)(NSNumber *_Nonnull tag, BOOL should
 typedef void (
     ^REAAnimationStartingBlock)(NSNumber *_Nonnull tag, LayoutAnimationType type, NSDictionary *_Nonnull yogaValues);
 typedef void (^REAAnimationRemovingBlock)(NSNumber *_Nonnull tag);
+typedef void (^REASharedTransitionRemovingBlock)(NSNumber *_Nonnull tag);
 #ifndef NDEBUG
 typedef void (^REACheckDuplicateSharedTagBlock)(REAUIView *view, NSNumber *_Nonnull viewTag);
 #endif
@@ -35,6 +36,7 @@ BOOL REANodeFind(id<RCTComponent> view, int (^block)(id<RCTComponent>));
 - (void)setHasAnimationBlock:(REAHasAnimationBlock)hasAnimation;
 - (void)setShouldAnimateExitingBlock:(REAShouldAnimateExitingBlock)shouldAnimateExiting;
 - (void)setAnimationRemovingBlock:(REAAnimationRemovingBlock)clearAnimation;
+- (void)setSharedTransitionRemovingBlock:(REASharedTransitionRemovingBlock)clearSharedTransition;
 #ifndef NDEBUG
 - (void)setCheckDuplicateSharedTagBlock:(REACheckDuplicateSharedTagBlock)checkDuplicateSharedTag;
 #endif
@@ -61,6 +63,7 @@ BOOL REANodeFind(id<RCTComponent> view, int (^block)(id<RCTComponent>));
 - (REAUIView *)viewForTag:(NSNumber *)tag;
 - (BOOL)hasAnimationForTag:(NSNumber *)tag type:(LayoutAnimationType)type;
 - (void)clearAnimationConfigForTag:(NSNumber *)tag;
+- (void)clearSharedTransitionConfigForTag:(NSNumber *)tag;
 - (void)startAnimationForTag:(NSNumber *)tag type:(LayoutAnimationType)type yogaValues:(NSDictionary *)yogaValues;
 - (void)onScreenRemoval:(REAUIView *)screen stack:(REAUIView *)stack;
 

package/apple/LayoutReanimation/REAAnimationsManager.m

@@ -43,6 +43,7 @@ BOOL REANodeFind(id<RCTComponent> view, int (^block)(id<RCTComponent>))
   REAHasAnimationBlock _hasAnimationForTag;
   REAShouldAnimateExitingBlock _shouldAnimateExiting;
   REAAnimationRemovingBlock _clearAnimationConfigForTag;
+  REASharedTransitionRemovingBlock _clearSharedTransitionConfigForTag;
   REASharedTransitionManager *_sharedTransitionManager;
 #ifndef NDEBUG
   REACheckDuplicateSharedTagBlock _checkDuplicateSharedTag;
@@ -132,6 +133,11 @@ BOOL REANodeFind(id<RCTComponent> view, int (^block)(id<RCTComponent>))
   _clearAnimationConfigForTag = clearAnimation;
 }
 
+- (void)setSharedTransitionRemovingBlock:(REASharedTransitionRemovingBlock)clearSharedTransition
+{
+  _clearSharedTransitionConfigForTag = clearSharedTransition;
+}
+
 #ifndef NDEBUG
 - (void)setCheckDuplicateSharedTagBlock:(REACheckDuplicateSharedTagBlock)checkDuplicateSharedTag
 {
@@ -611,6 +617,11 @@ BOOL REANodeFind(id<RCTComponent> view, int (^block)(id<RCTComponent>))
   _clearAnimationConfigForTag(tag);
 }
 
+- (void)clearSharedTransitionConfigForTag:(NSNumber *)tag
+{
+  _clearSharedTransitionConfigForTag(tag);
+}
+
 - (void)startAnimationForTag:(NSNumber *)tag type:(LayoutAnimationType)type yogaValues:(NSDictionary *)yogaValues
 {
   _startAnimationForTag(tag, type, yogaValues);

package/apple/LayoutReanimation/REASharedTransitionManager.m

@@ -29,6 +29,8 @@
   BOOL _isAsyncSharedTransitionConfigured;
   BOOL _isConfigured;
   BOOL _clearScreen;
+  BOOL _isInteractive;
+  REAUIView *_disappearingScreen;
 }
 
 /*
@@ -121,7 +123,10 @@ static REASharedTransitionManager *_sharedTransitionManager;
 {
   if ([views count] > 0) {
     NSArray *sharedViews = [self sortViewsByTags:views];
-    _sharedElements = [self getSharedElementForCurrentTransition:sharedViews withNewElements:YES];
+    _sharedElements = [self getSharedElementForCurrentTransition:sharedViews
+                                                 withNewElements:YES
+                                                     withOffsetX:0
+                                                     withOffsetY:0];
     [self resolveAnimationType:_sharedElements isInteractive:NO];
     _isAsyncSharedTransitionConfigured = YES;
   }
@@ -169,11 +174,16 @@ static REASharedTransitionManager *_sharedTransitionManager;
   [self startSharedTransition:sharedElementToRestart];
 }
 
-- (BOOL)configureAndStartSharedTransitionForViews:(NSArray<REAUIView *> *)views isInteractive:(BOOL)isInteractive
+- (BOOL)configureAndStartSharedTransitionForViews:(NSArray<REAUIView *> *)views
+                                    isInteractive:(BOOL)isInteractive
+                                      withOffsetX:(double)offsetX
+                                      withOffsetY:(double)offsetY
 {
   NSArray *sharedViews = [self sortViewsByTags:views];
   NSArray<REASharedElement *> *sharedElements = [self getSharedElementForCurrentTransition:sharedViews
-                                                                           withNewElements:NO];
+                                                                           withNewElements:NO
+                                                                               withOffsetX:offsetX
+                                                                               withOffsetY:offsetY];
   if ([sharedElements count] == 0) {
     return NO;
   }
@@ -198,6 +208,8 @@ static REASharedTransitionManager *_sharedTransitionManager;
 
 - (NSMutableArray<REASharedElement *> *)getSharedElementForCurrentTransition:(NSArray *)sharedViews
                                                              withNewElements:(BOOL)addedNewScreen
+                                                                 withOffsetX:(double)offsetX
+                                                                 withOffsetY:(double)offsetY
 {
   NSMutableArray<REAUIView *> *newTransitionViews = [NSMutableArray new];
   NSMutableArray<REASharedElement *> *newSharedElements = [NSMutableArray new];
@@ -266,7 +278,7 @@ static REASharedTransitionManager *_sharedTransitionManager;
       if (![screenUnderStackTop.reactTag isEqual:viewSourceParentScreen.reactTag] && !isInCurrentTransition) {
         continue;
       }
-    } else if (!addedNewScreen) {
+    } else if (!addedNewScreen && !isModal) {
       // is on top
       REAUIView *viewTargetParentScreen = [REAScreensHelper getScreenForView:viewTarget];
       // TODO macOS navigationController isn't available on macOS
@@ -282,7 +294,12 @@ static REASharedTransitionManager *_sharedTransitionManager;
       [_viewsToHide addObject:viewSource.reactTag];
     }
 
-    REASnapshot *sourceViewSnapshot = [[REASnapshot alloc] initWithAbsolutePosition:viewSource];
+    REASnapshot *sourceViewSnapshot;
+    if (!addedNewScreen) {
+      sourceViewSnapshot = _snapshotRegistry[viewSource.reactTag];
+    } else {
+      sourceViewSnapshot = [[REASnapshot alloc] initWithAbsolutePosition:viewSource];
+    }
     if (addedNewScreen && !_currentSharedTransitionViews[viewSource.reactTag]) {
       _snapshotRegistry[viewSource.reactTag] = sourceViewSnapshot;
     }
@@ -292,10 +309,9 @@ static REASharedTransitionManager *_sharedTransitionManager;
       targetViewSnapshot = [[REASnapshot alloc] initWithAbsolutePosition:viewTarget];
       _snapshotRegistry[viewTarget.reactTag] = targetViewSnapshot;
     } else {
-      targetViewSnapshot = _snapshotRegistry[viewTarget.reactTag];
-      if (targetViewSnapshot == nil) {
-        targetViewSnapshot = [[REASnapshot alloc] initWithAbsolutePosition:viewTarget];
-      }
+      targetViewSnapshot = [[REASnapshot alloc] initWithAbsolutePosition:viewTarget
+                                                             withOffsetX:offsetX
+                                                             withOffsetY:offsetY];
     }
 
     [newTransitionViews addObject:viewSource];
@@ -346,10 +362,12 @@ static REASharedTransitionManager *_sharedTransitionManager;
   dispatch_once(&onceToken, ^{
     SEL viewDidLayoutSubviewsSelector = @selector(viewDidLayoutSubviews);
     SEL notifyWillDisappearSelector = @selector(notifyWillDisappear);
+    SEL viewIsAppearingSelector = @selector(viewIsAppearing:);
     Class screenClass = [RNSScreen class];
     Class screenViewClass = [RNSScreenView class];
     BOOL allSelectorsAreAvailable = [RNSScreen instancesRespondToSelector:viewDidLayoutSubviewsSelector] &&
         [RNSScreenView instancesRespondToSelector:notifyWillDisappearSelector] &&
+        [RNSScreen instancesRespondToSelector:viewIsAppearingSelector] &&
         [RNSScreenView instancesRespondToSelector:@selector(isModal)]; // used by REAScreenHelper
 
     if (allSelectorsAreAvailable) {
@@ -361,12 +379,37 @@ static REASharedTransitionManager *_sharedTransitionManager;
                      forClass:screenViewClass
                          with:@selector(reanimated_notifyWillDisappear)
                     fromClass:[self class]];
+      [REAUtils swizzleMethod:viewIsAppearingSelector
+                     forClass:screenClass
+                         with:@selector(reanimated_viewIsAppearing:)
+                    fromClass:[self class]];
       _isConfigured = YES;
     }
   });
 #endif
 }
 
+- (void)setDisappearingScreen:(REAUIView *)view
+{
+  _disappearingScreen = view;
+  _isInteractive = [_sharedTransitionManager isInteractiveScreenChange:view];
+}
+
+- (REAUIView *)getDisappearingScreen
+{
+  return _disappearingScreen;
+}
+
+- (void)setIsInteractive:(BOOL)isInteractive
+{
+  _isInteractive = isInteractive;
+}
+
+- (BOOL)getIsInteractive
+{
+  return _isInteractive;
+}
+
 - (void)reanimated_viewDidLayoutSubviews
 {
   // call original method from react-native-screens, self == RNScreen
@@ -379,7 +422,28 @@ static REASharedTransitionManager *_sharedTransitionManager;
 {
   // call original method from react-native-screens, self == RNSScreenView
   [self reanimated_notifyWillDisappear];
-  [_sharedTransitionManager screenRemovedFromStack:(REAUIView *)self];
+  [_sharedTransitionManager makeSnapshotForScreenViews:(REAUIView *)self];
+  bool isModal = [REAScreensHelper isScreenModal:(REAUIView *)self];
+  if (isModal) {
+    [_sharedTransitionManager setIsInteractive:[_sharedTransitionManager isInteractiveScreenChange:(REAUIView *)self]];
+    [_sharedTransitionManager screenRemovedFromStack:(REAUIView *)self withOffsetX:0 withOffsetY:0];
+  } else {
+    [_sharedTransitionManager setDisappearingScreen:(REAUIView *)self];
+  }
+}
+
+- (void)reanimated_viewIsAppearing:(BOOL)animated
+{
+  // call original method from react-native-screens, self == RNSScreen
+  [self reanimated_viewIsAppearing:animated];
+  REAUIView *disappearingScreen = [_sharedTransitionManager getDisappearingScreen];
+  REAUIView *targetScreen = [self valueForKey:@"screenView"];
+  if (disappearingScreen != NULL) {
+    [_sharedTransitionManager screenRemovedFromStack:disappearingScreen
+                                         withOffsetX:-targetScreen.superview.frame.origin.x
+                                         withOffsetY:-targetScreen.superview.frame.origin.y];
+  }
+  [_sharedTransitionManager setDisappearingScreen:NULL];
 }
 
 - (void)screenAddedToStack:(REAUIView *)screen
@@ -389,14 +453,14 @@ static REASharedTransitionManager *_sharedTransitionManager;
   }
 }
 
-- (void)screenRemovedFromStack:(REAUIView *)screen
+- (void)screenRemovedFromStack:(REAUIView *)screen withOffsetX:(double)offsetX withOffsetY:(double)offsetY
 {
   _isStackDropped = NO;
   REAUIView *stack = [REAScreensHelper getStackForView:screen];
   bool isModal = [REAScreensHelper isScreenModal:screen];
   bool isRemovedInParentStack = [self isRemovedFromHigherStack:screen];
+  bool isInteractive = [self getIsInteractive];
   if ((stack != nil || isModal) && !isRemovedInParentStack) {
-    bool isInteractive = [self isInteractiveScreenChange:screen];
     // screen is removed from React tree (navigation.navigate(<screenName>))
     bool isScreenRemovedFromReactTree = [self isScreen:screen outsideStack:stack];
     // click on button goBack on native header
@@ -404,13 +468,16 @@ static REASharedTransitionManager *_sharedTransitionManager;
     bool shouldRunTransition = (isScreenRemovedFromReactTree || isTriggeredByGoBackButton) &&
         !(isInteractive && [_currentSharedTransitionViews count] > 0);
     if (shouldRunTransition) {
-      [self runSharedTransitionForSharedViewsOnScreen:screen isInteractive:isInteractive];
+      [self runSharedTransitionForSharedViewsOnScreen:screen
+                                        isInteractive:isInteractive
+                                          withOffsetX:offsetX
+                                          withOffsetY:offsetY];
     } else {
       [self makeSnapshotForScreenViews:screen];
     }
   } else {
     // removed stack
-    if (![self isInteractiveScreenChange:screen]) {
+    if (!isInteractive) {
       [self clearConfigForStackNow:stack];
     } else {
       _isStackDropped = YES;
@@ -436,7 +503,9 @@ static REASharedTransitionManager *_sharedTransitionManager;
       return false;
     }
     if ([self->_animationManager hasAnimationForTag:viewTag type:SHARED_ELEMENT_TRANSITION]) {
-      REASnapshot *snapshot = [[REASnapshot alloc] initWithAbsolutePosition:(REAUIView *)view];
+      REASnapshot *snapshot = [[REASnapshot alloc] initWithAbsolutePosition:(REAUIView *)view
+                                                                withOffsetX:0
+                                                                withOffsetY:0];
       self->_snapshotRegistry[viewTag] = snapshot;
     }
     return false;
@@ -487,7 +556,10 @@ static REASharedTransitionManager *_sharedTransitionManager;
   return NO;
 }
 
-- (void)runSharedTransitionForSharedViewsOnScreen:(REAUIView *)screen isInteractive:(BOOL)isInteractive
+- (void)runSharedTransitionForSharedViewsOnScreen:(REAUIView *)screen
+                                    isInteractive:(BOOL)isInteractive
+                                      withOffsetX:(double)offsetX
+                                      withOffsetY:(double)offsetY
 {
   NSMutableArray<REAUIView *> *removedViews = [NSMutableArray new];
   REANodeFind(screen, ^int(id<RCTComponent> view) {
@@ -496,7 +568,10 @@ static REASharedTransitionManager *_sharedTransitionManager;
     }
     return false;
   });
-  BOOL startedAnimation = [self configureAndStartSharedTransitionForViews:removedViews isInteractive:isInteractive];
+  BOOL startedAnimation = [self configureAndStartSharedTransitionForViews:removedViews
+                                                            isInteractive:isInteractive
+                                                              withOffsetX:offsetX
+                                                              withOffsetY:offsetY];
   if (startedAnimation) {
     _removedViews = removedViews;
   } else if (![self isInteractiveScreenChange:screen]) {
@@ -616,8 +691,9 @@ static REASharedTransitionManager *_sharedTransitionManager;
                                        isSharedTransition:YES];
       float originXByParent = [viewSourcePreviousSnapshot.values[@"originXByParent"] floatValue];
       float originYByParent = [viewSourcePreviousSnapshot.values[@"originYByParent"] floatValue];
-      CGRect frame = CGRectMake(originXByParent, originYByParent, view.frame.size.width, view.frame.size.height);
-      [view setFrame:frame];
+      float height = [viewSourcePreviousSnapshot.values[@"height"] floatValue];
+      float width = [viewSourcePreviousSnapshot.values[@"width"] floatValue];
+      [view setCenter:CGPointMake(originXByParent + width / 2.0, originYByParent + height / 2.0)];
     }
     [_sharedTransitionParent removeObjectForKey:viewTag];
     [_sharedTransitionInParentIndex removeObjectForKey:viewTag];
@@ -632,7 +708,7 @@ static REASharedTransitionManager *_sharedTransitionManager;
     [_removedViews removeObject:view];
   }
   if ([_removedViews containsObject:view]) {
-    [_animationManager clearAnimationConfigForTag:viewTag];
+    [_animationManager clearSharedTransitionConfigForTag:viewTag];
   }
   if (_removedViewRegistry[view.reactTag]) {
     return;
@@ -664,7 +740,7 @@ static REASharedTransitionManager *_sharedTransitionManager;
 {
   if (viewTag != nil) {
     [_snapshotRegistry removeObjectForKey:viewTag];
-    [_animationManager clearAnimationConfigForTag:viewTag];
+    [_animationManager clearSharedTransitionConfigForTag:viewTag];
   }
 }
 
@@ -716,8 +792,8 @@ static REASharedTransitionManager *_sharedTransitionManager;
 {
   NSMutableDictionary *workletValues = [_animationManager prepareDataForLayoutAnimatingWorklet:currentValues
                                                                                   targetValues:targetValues];
-  workletValues[@"currentTransformMatrix"] = currentValues[@"transformMatrix"];
-  workletValues[@"targetTransformMatrix"] = targetValues[@"transformMatrix"];
+  workletValues[@"currentTransformMatrix"] = currentValues[@"combinedTransformMatrix"];
+  workletValues[@"targetTransformMatrix"] = targetValues[@"combinedTransformMatrix"];
   workletValues[@"currentBorderRadius"] = currentValues[@"borderRadius"];
   workletValues[@"targetBorderRadius"] = targetValues[@"borderRadius"];
   return workletValues;

package/apple/LayoutReanimation/REASnapshot.h

@@ -9,6 +9,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (instancetype)init:(REAUIView *)view;
 - (instancetype)initWithAbsolutePosition:(REAUIView *)view;
+- (instancetype)initWithAbsolutePosition:(REAUIView *)view withOffsetX:(double)offsetX withOffsetY:(double)offsetY;
 
 @end
 

package/apple/LayoutReanimation/REASnapshot.m

@@ -15,25 +15,35 @@ const int DEFAULT_MODAL_TOP_OFFSET = 69; // Default iOS modal is shifted from sc
 - (instancetype)init:(REAUIView *)view
 {
   self = [super init];
-  [self makeSnapshotForView:view useAbsolutePositionOnly:NO];
+  [self makeSnapshotForView:view useAbsolutePositionOnly:NO withOffsetX:0 withOffsetY:0];
+  return self;
+}
+
+- (instancetype)initWithAbsolutePosition:(REAUIView *)view withOffsetX:(double)offsetX withOffsetY:(double)offsetY
+{
+  self = [super init];
+  [self makeSnapshotForView:view useAbsolutePositionOnly:YES withOffsetX:offsetX withOffsetY:offsetY];
   return self;
 }
 
 - (instancetype)initWithAbsolutePosition:(REAUIView *)view
 {
   self = [super init];
-  [self makeSnapshotForView:view useAbsolutePositionOnly:YES];
+  [self makeSnapshotForView:view useAbsolutePositionOnly:YES withOffsetX:0 withOffsetY:0];
   return self;
 }
 
-- (void)makeSnapshotForView:(REAUIView *)view useAbsolutePositionOnly:(BOOL)useAbsolutePositionOnly
+- (void)makeSnapshotForView:(REAUIView *)view
+    useAbsolutePositionOnly:(BOOL)useAbsolutePositionOnly
+                withOffsetX:(double)offsetX
+                withOffsetY:(double)offsetY
 {
 #if TARGET_OS_OSX
   REAUIView *mainWindow = UIApplication.sharedApplication.keyWindow;
 #else
   REAUIView *mainWindow = RCTKeyWindow();
 #endif
-  CGPoint absolutePosition = [[view superview] convertPoint:view.center toView:nil];
+  CGPoint absolutePosition = [[view superview] convertPoint:view.center toView:mainWindow];
   _values = [NSMutableDictionary new];
 #if TARGET_OS_OSX
   _values[@"windowWidth"] = [NSNumber numberWithDouble:mainWindow.frame.size.width];
@@ -44,8 +54,8 @@ const int DEFAULT_MODAL_TOP_OFFSET = 69; // Default iOS modal is shifted from sc
 #endif
   _values[@"width"] = [NSNumber numberWithDouble:(double)(view.bounds.size.width)];
   _values[@"height"] = [NSNumber numberWithDouble:(double)(view.bounds.size.height)];
-  _values[@"globalOriginX"] = [NSNumber numberWithDouble:absolutePosition.x - view.bounds.size.width / 2.0];
-  _values[@"globalOriginY"] = [NSNumber numberWithDouble:absolutePosition.y - view.bounds.size.height / 2.0];
+  _values[@"globalOriginX"] = [NSNumber numberWithDouble:offsetX + absolutePosition.x - view.bounds.size.width / 2.0];
+  _values[@"globalOriginY"] = [NSNumber numberWithDouble:offsetY + absolutePosition.y - view.bounds.size.height / 2.0];
   if (useAbsolutePositionOnly) {
     _values[@"originX"] = _values[@"globalOriginX"];
     _values[@"originY"] = _values[@"globalOriginY"];
@@ -77,22 +87,48 @@ const int DEFAULT_MODAL_TOP_OFFSET = 69; // Default iOS modal is shifted from sc
       _values[@"headerHeight"] = @(0);
     }
 
-    REAUIView *transformedView = [self findTransformedView:view];
+    // store the transofrmMatrix of this view, so that we can reestablish it later
+    CGAffineTransform transform = view.transform;
+    _values[@"transformMatrix"] = @[
+      @(transform.a),
+      @(transform.b),
+      @(0),
+      @(transform.c),
+      @(transform.d),
+      @(0),
+      @(transform.tx),
+      @(transform.ty),
+      @(1)
+    ];
+
+    transform = [self findCombinedTransform:view];
+    _values[@"combinedTransformMatrix"] = @[
+      @(transform.a),
+      @(transform.b),
+      @(0),
+      @(transform.c),
+      @(transform.d),
+      @(0),
+      @(transform.tx),
+      @(transform.ty),
+      @(1)
+    ];
+
+    REAUIView *transformedView = [self maybeFindTransitionView:view];
     if (transformedView != nil) {
       // iOS affine matrix: https://developer.apple.com/documentation/corefoundation/cgaffinetransform
-      CGAffineTransform transform = transformedView.transform;
-      NSNumber *a = @(transform.a);
-      NSNumber *b = @(transform.b);
-      NSNumber *c = @(transform.c);
-      NSNumber *d = @(transform.d);
-      NSNumber *tx = @(transform.tx);
-      NSNumber *ty = @(transform.tx);
-      _values[@"transformMatrix"] = @[ a, b, @(0), c, d, @(0), tx, ty, @(1) ];
-      _values[@"originX"] = @([_values[@"originX"] doubleValue] - [tx doubleValue]);
-      _values[@"originY"] = @([_values[@"originY"] doubleValue] - [ty doubleValue]);
-    } else {
-      // Identity matrix is an default value
-      _values[@"transformMatrix"] = @[ @(1), @(0), @(0), @(0), @(1), @(0), @(0), @(0), @(1) ];
+      transform = transformedView.transform;
+      // revert the transformation that was applied to the view when transition started, since we are intereseted only
+      // in the final result of the transition
+      CGPoint center = [[view superview] convertPoint:view.center toView:transformedView.superview];
+      CGPoint parentCenter = transformedView.center;
+      CGFloat x = center.x, y = center.y, a = transform.a, b = transform.b, c = transform.c, d = transform.d,
+              tx = transform.tx, ty = transform.ty, parentX = parentCenter.x, parentY = parentCenter.y;
+      center.x = (b - a) * (x - parentX - tx) / (b * c - a * d) + parentX;
+      center.y = (d - c) * (y - parentY - ty) / (a * d - b * c) + parentY;
+      CGPoint absolute = [[transformedView superview] convertPoint:center toView:nil];
+      _values[@"originX"] = [NSNumber numberWithDouble:offsetX + absolute.x - view.bounds.size.width / 2.0];
+      _values[@"originY"] = [NSNumber numberWithDouble:offsetY + absolute.y - view.bounds.size.height / 2.0];
     }
 #if defined(RCT_NEW_ARCH_ENABLED) || TARGET_OS_TV
     _values[@"borderRadius"] = @(0);
@@ -110,26 +146,31 @@ const int DEFAULT_MODAL_TOP_OFFSET = 69; // Default iOS modal is shifted from sc
   }
 }
 
-- (REAUIView *)findTransformedView:(REAUIView *)view
+- (CGAffineTransform)findCombinedTransform:(REAUIView *)view
 {
-  REAUIView *transformedView;
-  bool isTransformed = false;
-  do {
-    if (transformedView == nil) {
-      transformedView = view;
-    } else {
-      transformedView = transformedView.superview;
+  CGAffineTransform transform = view.transform;
+  view = view.superview;
+  while (view != nil && ![REAScreensHelper isRNSScreenType:view]) {
+    // ignore transforms that are caused by transitions
+    if (![view.superview isKindOfClass:NSClassFromString(@"UITransitionView")]) {
+      CGAffineTransform t = view.transform;
+      // we are ignoring translations in superviews, since the positioning obtained by converting the center point (and
+      // applying it's view transforms) to the main window is already correct, here we only care about scale, shear and
+      // rotation
+      transform = CGAffineTransformConcat(transform, CGAffineTransformMake(t.a, t.b, t.c, t.d, 0, 0));
     }
-    CGAffineTransform transform = transformedView.transform;
-    isTransformed = transform.a != 1 || transform.b != 0 || transform.c != 0 || transform.d != 1 || transform.tx != 0 ||
-        transform.ty != 0;
-  } while (!isTransformed &&
-           transformedView != nil
-           // Ignore views above screen
-           && ![REAScreensHelper isRNSScreenType:transformedView]);
+    view = view.superview;
+  }
+  return transform;
+}
 
-  if (isTransformed && transformedView != nil) {
-    return transformedView;
+- (REAUIView *)maybeFindTransitionView:(REAUIView *)view
+{
+  while (view != nil && ![REAScreensHelper isRNSScreenType:view]) {
+    if ([view.superview isKindOfClass:NSClassFromString(@"UITransitionView")]) {
+      return view;
+    }
+    view = view.superview;
   }
   return nil;
 }