@onekeyfe/react-native-pager-view 1.1.35

package/ios/RNCPagerViewComponentView.mm

@@ -0,0 +1,704 @@
+#import <Foundation/Foundation.h>
+#import "RNCPagerViewComponentView.h"
+#import <react/renderer/components/pagerview/ComponentDescriptors.h>
+#import <react/renderer/components/pagerview/EventEmitters.h>
+#import <react/renderer/components/pagerview/Props.h>
+#import <react/renderer/components/pagerview/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import "React/RCTConversions.h"
+
+#import "RCTOnPageScrollEvent.h"
+
+using namespace facebook::react;
+
+@interface RNCPagerViewComponentView () <RCTRNCViewPagerViewProtocol, UIPageViewControllerDataSource, UIPageViewControllerDelegate, UIScrollViewDelegate, UIGestureRecognizerDelegate>
+
+@property(nonatomic, strong) UIPageViewController *nativePageViewController;
+@property(nonatomic, strong) NSMutableArray<UIViewController *> *nativeChildrenViewControllers;
+
+@end
+
+@implementation RNCPagerViewComponentView {
+    LayoutMetrics _layoutMetrics;
+    LayoutMetrics _oldLayoutMetrics;
+    UIScrollView *scrollView;
+    BOOL transitioning;
+    NSInteger _currentIndex;
+    NSInteger _destinationIndex;
+    BOOL _overdrag;
+    NSString *_layoutDirection;
+    BOOL _scrollEnabled;
+    // _isBeingRecycled: synchronous guard, only true during prepareForRecycle execution
+    BOOL _isBeingRecycled;
+    // _generation: async guard for recycle-and-reuse, incremented in prepareForRecycle
+    NSUInteger _generation;
+    // _transitionId: async guard for superseded transitions, incremented each setPagerViewControllers call
+    NSUInteger _transitionId;
+    // _pendingGoToIndex: stores the latest blocked animated transition target, drained after current transition completes
+    NSInteger _pendingGoToIndex;
+    // _nestedScrollEnabled: when YES, this inner PagerView coordinates gestures with an outer PagerView
+    BOOL _nestedScrollEnabled;
+    // _blockerGesture: gate gesture that blocks inner scroll at page boundaries when nested
+    UIPanGestureRecognizer *_blockerGesture;
+}
+
+// Needed because of this: https://github.com/facebook/react-native/pull/37274
++ (void)load
+{
+  [super load];
+}
+
+- (void)initializeNativePageViewController {
+    const auto &viewProps = *std::static_pointer_cast<const RNCViewPagerProps>(_props);
+    NSDictionary *options = @{ UIPageViewControllerOptionInterPageSpacingKey: @(viewProps.pageMargin) };
+    UIPageViewControllerNavigationOrientation orientation = UIPageViewControllerNavigationOrientationHorizontal;
+    switch (viewProps.orientation) {
+        case RNCViewPagerOrientation::Horizontal:
+            orientation = UIPageViewControllerNavigationOrientationHorizontal;
+            break;
+        case RNCViewPagerOrientation::Vertical:
+            orientation = UIPageViewControllerNavigationOrientationVertical;
+            break;
+    }
+    _nativePageViewController = [[UIPageViewController alloc]
+                                 initWithTransitionStyle: UIPageViewControllerTransitionStyleScroll
+                                 navigationOrientation:orientation
+                                 options:options];
+    _nativePageViewController.dataSource = self;
+    _nativePageViewController.delegate = self;
+    _nativePageViewController.view.frame = self.frame;
+    self.contentView = _nativePageViewController.view;
+    
+    for (UIView *subview in _nativePageViewController.view.subviews) {
+        if([subview isKindOfClass:UIScrollView.class]){
+            ((UIScrollView *)subview).delegate = self;
+            ((UIScrollView *)subview).delaysContentTouches = NO;
+            scrollView = (UIScrollView *)subview;
+        }
+    }
+
+    [self applyScrollEnabled];
+    [self applyNestedScrollBlocker];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    if (self = [super initWithFrame:frame]) {
+        static const auto defaultProps = std::make_shared<const RNCViewPagerProps>();
+        _props = defaultProps;
+        _nativeChildrenViewControllers = [[NSMutableArray alloc] init];
+        _currentIndex = -1;
+        _destinationIndex = -1;
+        _layoutDirection = @"ltr";
+        _overdrag = NO;
+        _scrollEnabled = YES;
+        _isBeingRecycled = NO;
+        _pendingGoToIndex = -1;
+        _nestedScrollEnabled = NO;
+    }
+    
+    return self;
+}
+
+- (void)willMoveToSuperview:(UIView *)newSuperview {
+    if (newSuperview != nil) {
+        [self initializeNativePageViewController];
+        [self goTo:_currentIndex animated:NO];
+    }
+}
+
+
+#pragma mark - React API
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+    if (_isBeingRecycled) {
+        return;
+    }
+    UIViewController *vc = [UIViewController new];
+    [vc.view addSubview:childComponentView];
+    [_nativeChildrenViewControllers insertObject:vc atIndex:index];
+    [self goTo:_currentIndex animated:NO];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+    if (_isBeingRecycled) {
+        return;
+    }
+
+    if (index >= _nativeChildrenViewControllers.count) {
+        return;
+    }
+
+    [childComponentView removeFromSuperview];
+    [_nativeChildrenViewControllers removeObjectAtIndex:index];
+ 
+    NSInteger maxPage = _nativeChildrenViewControllers.count - 1;
+    
+    if (_currentIndex >= maxPage) {
+        if (maxPage >= 0) {
+            [self goTo:maxPage animated:NO];
+        }
+    }
+}
+
+
+-(void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics {
+    _oldLayoutMetrics = oldLayoutMetrics;
+    _layoutMetrics = layoutMetrics;
+  
+    if (transitioning) {
+      return;
+    }
+  
+    [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:_oldLayoutMetrics];
+}
+
+
+-(void)prepareForRecycle {
+    _isBeingRecycled = YES;
+    _generation++;
+
+    // Cancel any ongoing transitions
+    if (_nativePageViewController != nil && transitioning) {
+        transitioning = NO;
+    }
+
+    // Clear view controllers before recycling
+    [_nativeChildrenViewControllers removeAllObjects];
+
+    // Remove blocker gesture before recycling
+    if (_blockerGesture != nil) {
+        [self removeGestureRecognizer:_blockerGesture];
+        _blockerGesture = nil;
+    }
+
+    [super prepareForRecycle];
+    _nativePageViewController = nil;
+    _currentIndex = -1;
+    _scrollEnabled = YES;
+    _pendingGoToIndex = -1;
+    _nestedScrollEnabled = NO;
+    _isBeingRecycled = NO;
+}
+
+- (void)shouldDismissKeyboard:(RNCViewPagerKeyboardDismissMode)dismissKeyboard {
+#if !TARGET_OS_VISION
+    UIScrollViewKeyboardDismissMode dismissKeyboardMode = UIScrollViewKeyboardDismissModeNone;
+    switch (dismissKeyboard) {
+        case RNCViewPagerKeyboardDismissMode::None:
+            dismissKeyboardMode = UIScrollViewKeyboardDismissModeNone;
+            break;
+        case RNCViewPagerKeyboardDismissMode::OnDrag:
+            dismissKeyboardMode = UIScrollViewKeyboardDismissModeOnDrag;
+            break;
+    }
+    scrollView.keyboardDismissMode = dismissKeyboardMode;
+#endif
+}
+
+- (void)applyScrollEnabled {
+  scrollView.scrollEnabled = _scrollEnabled;
+}
+
+
+- (void)updateProps:(const facebook::react::Props::Shared &)props oldProps:(const facebook::react::Props::Shared &)oldProps{
+    const auto &oldScreenProps = *std::static_pointer_cast<const RNCViewPagerProps>(_props);
+    const auto &newScreenProps = *std::static_pointer_cast<const RNCViewPagerProps>(props);
+    
+    // change index only once
+    if (_currentIndex == -1) {
+        _currentIndex = newScreenProps.initialPage;
+        [self shouldDismissKeyboard: newScreenProps.keyboardDismissMode];
+    }
+    
+    const auto newLayoutDirectionStr = RCTNSStringFromString(toString(newScreenProps.layoutDirection));
+    
+    
+    if (_layoutDirection != newLayoutDirectionStr) {
+        _layoutDirection = newLayoutDirectionStr;
+    }
+    
+    if (oldScreenProps.keyboardDismissMode != newScreenProps.keyboardDismissMode) {
+        [self shouldDismissKeyboard: newScreenProps.keyboardDismissMode];
+    }
+    
+    if (oldScreenProps.scrollEnabled != newScreenProps.scrollEnabled) {
+        _scrollEnabled = newScreenProps.scrollEnabled;
+        [self applyScrollEnabled];
+    }
+    
+    if (newScreenProps.overdrag != _overdrag) {
+        _overdrag = newScreenProps.overdrag;
+    }
+
+    if (oldScreenProps.nestedScrollEnabled != newScreenProps.nestedScrollEnabled) {
+        _nestedScrollEnabled = newScreenProps.nestedScrollEnabled;
+        [self applyNestedScrollBlocker];
+    }
+
+    [super updateProps:props oldProps:oldProps];
+}
+
+
+#pragma mark - Internal methods
+
+- (void)disableSwipe {
+    self.nativePageViewController.view.userInteractionEnabled = NO;
+}
+
+- (void)enableSwipe {
+    self.nativePageViewController.view.userInteractionEnabled = YES;
+}
+
+- (void)goTo:(NSInteger)index animated:(BOOL)animated {
+    NSInteger numberOfPages = _nativeChildrenViewControllers.count;
+    
+    // Check recycling state BEFORE disableSwipe to avoid state inconsistency
+    if (_isBeingRecycled) {
+#ifdef DEBUG
+        NSLog(@"[PagerView] goTo blocked: view is being recycled (index=%ld)", (long)index);
+#endif
+        return;
+    }
+
+    [self disableSwipe];
+    
+    _destinationIndex = index;
+    
+    
+    if (numberOfPages == 0 || index < 0 || index > numberOfPages - 1) {
+        [self enableSwipe];
+        return;
+    }
+    
+    BOOL isForward = (index > _currentIndex && [self isLtrLayout]) || (index < _currentIndex && ![self isLtrLayout]);
+    UIPageViewControllerNavigationDirection direction = isForward ? UIPageViewControllerNavigationDirectionForward : UIPageViewControllerNavigationDirectionReverse;
+    
+    long diff = labs(index - _currentIndex);
+    
+    [self setPagerViewControllers:index
+                        direction:direction
+                         animated:diff == 0 ? NO : animated];
+    
+}
+
+- (void)setPagerViewControllers:(NSInteger)index
+                      direction:(UIPageViewControllerNavigationDirection)direction
+                       animated:(BOOL)animated{
+    if (_nativePageViewController == nil || _isBeingRecycled) {
+#ifdef DEBUG
+        NSLog(@"[PagerView] setPagerViewControllers blocked: pageVC=%@ recycled=%d index=%ld",
+              _nativePageViewController ? @"EXISTS" : @"NIL", _isBeingRecycled, (long)index);
+#endif
+        [self enableSwipe];
+        return;
+    }
+  
+    // Validate index bounds
+    if (index < 0 || index >= _nativeChildrenViewControllers.count) {
+#ifdef DEBUG
+        NSLog(@"[PagerView] setPagerViewControllers blocked: index %ld out of bounds (count=%lu)",
+              (long)index, (unsigned long)_nativeChildrenViewControllers.count);
+#endif
+        [self enableSwipe];
+        return;
+    }
+
+    // Validate view controller and its view
+    UIViewController *targetVC = [_nativeChildrenViewControllers objectAtIndex:index];
+    if (targetVC == nil || targetVC.view == nil) {
+#ifdef DEBUG
+        NSLog(@"[PagerView] setPagerViewControllers blocked: targetVC=%@ view=%@ index=%ld",
+              targetVC ? @"EXISTS" : @"NIL", targetVC.view ? @"EXISTS" : @"NIL", (long)index);
+#endif
+        [self enableSwipe];
+        return;
+    }
+
+    // Note: Do NOT check superview/window == nil here!
+    // Target page views are expected to have nil superview/window before being added to pageViewController
+    // Checking for nil superview/window would block all legitimate page transitions
+
+    // Prevent calling setViewControllers during an ongoing animated transition.
+    // UIPageViewController's internal _UIQueuingScrollView does not support
+    // concurrent enqueued transitions and will crash with
+    // "Duplicate states in queue" (NSInternalInconsistencyException).
+    // Note: Non-animated transitions (animated=NO) are synchronous and bypass
+    // the internal _UIQueuingScrollView queue, so they are safe during an ongoing transition.
+    if (transitioning && animated) {
+#ifdef DEBUG
+        NSLog(@"[PagerView] setPagerViewControllers deferred: already transitioning (index=%ld)", (long)index);
+#endif
+        _pendingGoToIndex = index;
+        [self enableSwipe];
+        return;
+    }
+
+    // Clear any pending transition since we are now starting a fresh one
+    _pendingGoToIndex = -1;
+
+    transitioning = YES;
+
+    __weak RNCPagerViewComponentView *weakSelf = self;
+    NSUInteger capturedGeneration = _generation;
+    _transitionId++;
+    NSUInteger capturedTransitionId = _transitionId;
+    [_nativePageViewController setViewControllers:@[targetVC]
+                                        direction:direction
+                                         animated:animated
+                                       completion:^(BOOL finished) {
+        __strong RNCPagerViewComponentView *strongSelf = weakSelf;
+        if (strongSelf == nil) {
+            return;
+        }
+
+        // View was recycled and possibly reused since this animation started
+        if (strongSelf->_isBeingRecycled || strongSelf->_generation != capturedGeneration) {
+            // Do NOT reset transitioning here — a new lifecycle owns that state
+            return;
+        }
+
+        // A newer transition was started, this completion is stale
+        if (strongSelf->_transitionId != capturedTransitionId) {
+            // Do NOT reset transitioning — the newer transition owns that state
+            return;
+        }
+
+        // Only reset transitioning when this completion corresponds to the current transition
+        strongSelf->transitioning = NO;
+
+        [strongSelf enableSwipe];
+        strongSelf->_currentIndex = index;
+        if (strongSelf->_eventEmitter != nullptr ) {
+            const auto eventEmitter = [strongSelf pagerEventEmitter];
+            if (eventEmitter) {
+                int position = (int) index;
+                eventEmitter->onPageSelected(RNCViewPagerEventEmitter::OnPageSelected{.position =  static_cast<double>(position)});
+            }
+        }
+        [strongSelf updateLayoutMetrics:strongSelf->_layoutMetrics oldLayoutMetrics:strongSelf->_oldLayoutMetrics];
+
+        // Drain pending transition that was blocked while this animation was in-flight
+        NSInteger pending = strongSelf->_pendingGoToIndex;
+        if (pending >= 0 && pending != index) {
+            strongSelf->_pendingGoToIndex = -1;
+            [strongSelf goTo:pending animated:YES];
+        }
+    }];
+}
+
+
+- (UIViewController *)nextControllerForController:(UIViewController *)controller
+                                      inDirection:(UIPageViewControllerNavigationDirection)direction {
+    NSUInteger numberOfPages = _nativeChildrenViewControllers.count;
+
+    if (_isBeingRecycled || numberOfPages == 0) {
+        return nil;
+    }
+
+    NSInteger index = [_nativeChildrenViewControllers indexOfObject:controller];
+    
+    if (index == NSNotFound) {
+        return nil;
+    }
+    
+    direction == UIPageViewControllerNavigationDirectionForward ? index++ : index--;
+    
+    if (index < 0 || (index > (numberOfPages - 1))) {
+        return nil;
+    }
+    
+    return [_nativeChildrenViewControllers objectAtIndex:index];
+}
+
+- (UIViewController *)currentlyDisplayed {
+    return _nativePageViewController.viewControllers.firstObject;
+}
+
+#pragma mark - UIScrollViewDelegate
+
+- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView {
+    if (_isBeingRecycled) {
+        return;
+    }
+    const auto eventEmitter = [self pagerEventEmitter];
+    if (!eventEmitter) {
+        return;
+    }
+    eventEmitter->onPageScrollStateChanged(RNCViewPagerEventEmitter::OnPageScrollStateChanged{.pageScrollState =  RNCViewPagerEventEmitter::OnPageScrollStateChangedPageScrollState::Dragging });
+}
+
+- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView withVelocity:(CGPoint)velocity targetContentOffset:(inout CGPoint *)targetContentOffset {
+    if (_isBeingRecycled) {
+        return;
+    }
+    const auto eventEmitter = [self pagerEventEmitter];
+    if (!eventEmitter) {
+        return;
+    }
+    eventEmitter->onPageScrollStateChanged(RNCViewPagerEventEmitter::OnPageScrollStateChanged{.pageScrollState =  RNCViewPagerEventEmitter::OnPageScrollStateChangedPageScrollState::Settling });
+    
+    if (!_overdrag) {
+        NSInteger maxIndex = _nativeChildrenViewControllers.count - 1;
+        BOOL isFirstPage = [self isLtrLayout] ? _currentIndex == 0 : _currentIndex == maxIndex;
+        BOOL isLastPage = [self isLtrLayout] ? _currentIndex == maxIndex : _currentIndex == 0;
+        CGFloat contentOffset = [self isHorizontal] ? scrollView.contentOffset.x : scrollView.contentOffset.y;
+        CGFloat topBound = [self isHorizontal] ? scrollView.bounds.size.width : scrollView.bounds.size.height;
+        
+        if ((isFirstPage && contentOffset <= topBound) || (isLastPage && contentOffset >= topBound)) {
+            CGPoint croppedOffset = [self isHorizontal] ? CGPointMake(topBound, 0) : CGPointMake(0, topBound);
+            *targetContentOffset = croppedOffset;
+            
+            eventEmitter->onPageScrollStateChanged(RNCViewPagerEventEmitter::OnPageScrollStateChanged{.pageScrollState =  RNCViewPagerEventEmitter::OnPageScrollStateChangedPageScrollState::Idle });
+        }
+    }
+}
+
+- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
+    if (_isBeingRecycled) {
+        return;
+    }
+    const auto eventEmitter = [self pagerEventEmitter];
+    if (!eventEmitter) {
+        return;
+    }
+    eventEmitter->onPageScrollStateChanged(RNCViewPagerEventEmitter::OnPageScrollStateChanged{.pageScrollState =  RNCViewPagerEventEmitter::OnPageScrollStateChangedPageScrollState::Idle });
+}
+
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
+    if (_isBeingRecycled) {
+        return;
+    }
+    BOOL isHorizontal = [self isHorizontal];
+    CGFloat contentOffset = isHorizontal ? scrollView.contentOffset.x : scrollView.contentOffset.y;
+    CGFloat frameSize = isHorizontal ? scrollView.frame.size.width : scrollView.frame.size.height;
+    
+    if (frameSize == 0) {
+        return;
+    }
+
+    float offset = (contentOffset - frameSize) / frameSize;
+    float absoluteOffset = fabs(offset);
+    NSInteger position = _currentIndex;
+    
+    BOOL isHorizontalRtl = [self isHorizontalRtlLayout];
+    BOOL isAnimatingBackwards = isHorizontalRtl ? offset > 0.05f : offset < 0;
+    BOOL isBeingMovedByNestedScrollView = !scrollView.isDragging && !scrollView.isTracking;
+    if (scrollView.isDragging || isBeingMovedByNestedScrollView) {
+        _destinationIndex = isAnimatingBackwards ? _currentIndex - 1 : _currentIndex + 1;
+    }
+    
+    if (isAnimatingBackwards) {
+        position = _destinationIndex;
+        absoluteOffset = fmax(0, 1 - absoluteOffset);
+    }
+    
+    if (!_overdrag) {
+        NSInteger maxIndex = _nativeChildrenViewControllers.count - 1;
+        NSInteger firstPageIndex = isHorizontalRtl ? maxIndex : 0;
+        NSInteger lastPageIndex = isHorizontalRtl ? 0 : maxIndex;
+        BOOL isFirstPage = _currentIndex == firstPageIndex;
+        BOOL isLastPage = _currentIndex == lastPageIndex;
+        CGFloat topBound = isHorizontal ? scrollView.bounds.size.width : scrollView.bounds.size.height;
+        
+        if ((isFirstPage && contentOffset <= topBound) || (isLastPage && contentOffset >= topBound)) {
+            CGPoint croppedOffset = isHorizontal ? CGPointMake(topBound, 0) : CGPointMake(0, topBound);
+            scrollView.contentOffset = croppedOffset;
+            absoluteOffset = 0;
+            position = isLastPage ? lastPageIndex : firstPageIndex;
+        }
+    }
+    
+    float interpolatedOffset = absoluteOffset * labs(_destinationIndex - _currentIndex);
+    [self sendScrollEventsForPosition:position offset:interpolatedOffset];
+}
+
+
+#pragma mark - UIPageViewControllerDelegate
+
+- (void)pageViewController:(UIPageViewController *)pageViewController
+        didFinishAnimating:(BOOL)finished
+   previousViewControllers:(nonnull NSArray<UIViewController *> *)previousViewControllers
+       transitionCompleted:(BOOL)completed {
+    if (_isBeingRecycled) {
+        return;
+    }
+    if (completed) {
+        UIViewController* currentVC = [self currentlyDisplayed];
+        NSUInteger currentIndex = [_nativeChildrenViewControllers indexOfObject:currentVC];
+        _currentIndex = currentIndex;
+        int position = (int) currentIndex;
+        const auto eventEmitter = [self pagerEventEmitter];
+        if (eventEmitter) {
+            eventEmitter->onPageSelected(RNCViewPagerEventEmitter::OnPageSelected{.position =  static_cast<double>(position)});
+        }
+    }
+}
+
+#pragma mark - UIPageViewControllerDataSource
+
+- (UIViewController *)pageViewController:(UIPageViewController *)pageViewController
+       viewControllerAfterViewController:(UIViewController *)viewController {
+    
+    UIPageViewControllerNavigationDirection direction = [self isLtrLayout] ? UIPageViewControllerNavigationDirectionForward : UIPageViewControllerNavigationDirectionReverse;
+    return [self nextControllerForController:viewController inDirection:direction];
+}
+
+- (UIViewController *)pageViewController:(UIPageViewController *)pageViewController
+      viewControllerBeforeViewController:(UIViewController *)viewController {
+    UIPageViewControllerNavigationDirection direction = [self isLtrLayout] ? UIPageViewControllerNavigationDirectionReverse : UIPageViewControllerNavigationDirectionForward;
+    return [self nextControllerForController:viewController inDirection:direction];
+}
+
+#pragma mark - Imperative methods exposed to React Native
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+   RCTRNCViewPagerHandleCommand(self, commandName, args);
+}
+
+- (void)setPage:(NSInteger)index {
+    [self goTo:index animated:YES];
+}
+
+- (void)setPageWithoutAnimation:(NSInteger)index {
+    [self goTo:index animated:NO];
+}
+
+- (void)setScrollEnabledImperatively:(BOOL)scrollEnabled {
+    _scrollEnabled = scrollEnabled;
+    [self applyScrollEnabled];
+}
+
+#pragma mark - Nested Scroll Gesture Coordination
+
+- (void)applyNestedScrollBlocker {
+    if (scrollView == nil) return;
+
+    if (_nestedScrollEnabled && _blockerGesture == nil) {
+        _blockerGesture = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(blockerGestureFired:)];
+        _blockerGesture.delegate = self;
+        // Cancel touches so the blocker never actually scrolls anything
+        _blockerGesture.cancelsTouchesInView = NO;
+        _blockerGesture.delaysTouchesBegan = NO;
+        [self addGestureRecognizer:_blockerGesture];
+        // Inner scroll view pan must wait for the blocker to fail before it can begin
+        [scrollView.panGestureRecognizer requireGestureRecognizerToFail:_blockerGesture];
+    } else if (!_nestedScrollEnabled && _blockerGesture != nil) {
+        [self removeGestureRecognizer:_blockerGesture];
+        _blockerGesture = nil;
+    }
+}
+
+// The blocker gesture never actually does anything — it only serves as a gate
+- (void)blockerGestureFired:(UIPanGestureRecognizer *)recognizer {
+    // Immediately cancel so it doesn't interfere with other gestures
+    if (recognizer.state == UIGestureRecognizerStateBegan) {
+        recognizer.state = UIGestureRecognizerStateCancelled;
+    }
+}
+
+#pragma mark - UIGestureRecognizerDelegate
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer {
+    if (gestureRecognizer != _blockerGesture) return YES;
+    if (!_nestedScrollEnabled) return NO;
+    if (![gestureRecognizer isKindOfClass:[UIPanGestureRecognizer class]]) return NO;
+
+    UIPanGestureRecognizer *pan = (UIPanGestureRecognizer *)gestureRecognizer;
+    CGPoint velocity = [pan velocityInView:self];
+    NSInteger pageCount = _nativeChildrenViewControllers.count;
+
+    if (pageCount == 0) return NO;
+    if (_currentIndex < 0 || _currentIndex >= pageCount) return NO;
+
+    // Nested coordination is designed for horizontal inner/outer pagers only.
+    // For vertical pagers, do not block so inner scrolling keeps working.
+    BOOL isHorizontal = [self isHorizontal];
+    if (!isHorizontal) return NO;
+
+    // Only edge-block for gestures that are primarily horizontal.
+    // This avoids accidental outer-tab switches on vertical/diagonal content scrolls.
+    CGFloat absVelocityX = fabs(velocity.x);
+    CGFloat absVelocityY = fabs(velocity.y);
+    if (absVelocityX <= absVelocityY) return NO;
+    if (absVelocityX < 1.0f) return NO;
+
+    BOOL isLtr = [self isLtrLayout];
+    NSInteger firstPageIndex = isLtr ? 0 : pageCount - 1;
+    NSInteger lastPageIndex = isLtr ? pageCount - 1 : 0;
+
+    // At first page, swiping backward → blocker begins → inner scroll blocked → outer takes over
+    if (_currentIndex == firstPageIndex && velocity.x > 0) return YES;
+    // At last page, swiping forward → blocker begins → inner scroll blocked → outer takes over
+    if (_currentIndex == lastPageIndex && velocity.x < 0) return YES;
+
+    // Not at boundary or swiping inward → blocker fails → inner scroll works normally
+    return NO;
+}
+
+// Allow the blocker to be recognized simultaneously so it doesn't steal from vertical scrolls
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
+    if (gestureRecognizer == _blockerGesture) return YES;
+    return NO;
+}
+
+#pragma mark - Helpers
+
+- (BOOL)isHorizontalRtlLayout {
+    return self.isHorizontal && !self.isLtrLayout;
+}
+
+- (BOOL)isHorizontal {
+    return _nativePageViewController.navigationOrientation == UIPageViewControllerNavigationOrientationHorizontal;
+}
+
+- (BOOL)isLtrLayout {
+    return [_layoutDirection isEqualToString: @"ltr"];
+}
+
+- (std::shared_ptr<const RNCViewPagerEventEmitter>)pagerEventEmitter
+{
+  if (!_eventEmitter) {
+    return nullptr;
+  }
+
+  assert(std::dynamic_pointer_cast<const RNCViewPagerEventEmitter>(_eventEmitter));
+  return std::static_pointer_cast<const RNCViewPagerEventEmitter>(_eventEmitter);
+}
+
+- (void)sendScrollEventsForPosition:(NSInteger)position offset:(CGFloat)offset {
+    const auto eventEmitter = [self pagerEventEmitter];
+    if (eventEmitter) {
+        eventEmitter->onPageScroll(RNCViewPagerEventEmitter::OnPageScroll{
+            .position = static_cast<double>(position),
+            .offset = offset
+        });
+    }
+  
+    // This is temporary workaround to allow animations based on onPageScroll event
+    // until Fabric implements proper NativeAnimationDriver,
+    // see: https://github.com/facebook/react-native/blob/44f431b471c243c92284aa042d3807ba4d04af65/packages/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm#L59
+    RCTOnPageScrollEvent *event = [[RCTOnPageScrollEvent alloc] initWithReactTag:@(self.tag)
+                                                                        position:@(position)
+                                                                          offset:@(offset)];
+    NSDictionary *userInfo = @{@"event": event};
+    [[NSNotificationCenter defaultCenter] postNotificationName:@"RCTNotifyEventDispatcherObserversOfEvent_DEPRECATED"
+                                                        object:nil
+                                                      userInfo:userInfo];
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<RNCViewPagerComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNCViewPagerCls(void)
+{
+    return RNCPagerViewComponentView.class;
+}