@onekeyfe/react-native-pager-view 3.0.111 → 3.0.113

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -0,0 +1,738 @@
+#import "RNCCollapsiblePagerViewComponentView.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 "React/RCTConversions.h"
+
+using namespace facebook::react;
+
+static void *RNCCollapsiblePagerContentOffsetContext = &RNCCollapsiblePagerContentOffsetContext;
+
+@interface RNCCollapsiblePagerViewComponentView () <
+  RCTRNCCollapsiblePagerViewViewProtocol,
+  UIPageViewControllerDataSource,
+  UIPageViewControllerDelegate,
+  UIScrollViewDelegate
+>
+@end
+
+@implementation RNCCollapsiblePagerViewComponentView {
+  UIView *_containerView;
+  UIPageViewController *_pageViewController;
+  UIScrollView *_pagerScrollView;
+  NSMutableArray<UIView<RCTComponentViewProtocol> *> *_logicalChildren;
+  NSMutableArray<UIViewController *> *_pageControllers;
+  UIView *_headerView;
+  UIView *_stickyHeaderView;
+  NSInteger _currentIndex;
+  NSInteger _destinationIndex;
+  NSInteger _pendingInitialPage;
+  NSInteger _headerHeight;
+  NSInteger _stickyHeaderHeight;
+  CGFloat _headerOffset;
+  BOOL _scrollEnabled;
+  BOOL _transitioning;
+  BOOL _hasAppliedInitialPage;
+  NSString *_layoutDirection;
+  NSArray<NSString *> *_pageKeys;
+  NSString *_retainedPages;
+  NSMutableDictionary<NSString *, NSNumber *> *_pageOffsets;
+  NSMapTable<UIScrollView *, NSValue *> *_originalInsets;
+  NSMapTable<UIScrollView *, NSValue *> *_originalIndicatorInsets;
+  NSMapTable<UIScrollView *, NSNumber *> *_originalAlwaysBounceVertical;
+  NSMapTable<UIScrollView *, NSNumber *> *_originalInsetAdjustmentBehavior;
+  __weak UIScrollView *_observedScrollView;
+  BOOL _observingContentOffset;
+  BOOL _isBeingRecycled;
+  NSUInteger _generation;
+}
+
++ (void)load
+{
+  [super load];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNCCollapsiblePagerViewProps>();
+    _props = defaultProps;
+    _logicalChildren = [NSMutableArray new];
+    _pageControllers = [NSMutableArray new];
+    _pageOffsets = [NSMutableDictionary new];
+    _originalInsets = [NSMapTable weakToStrongObjectsMapTable];
+    _originalIndicatorInsets = [NSMapTable weakToStrongObjectsMapTable];
+    _originalAlwaysBounceVertical = [NSMapTable weakToStrongObjectsMapTable];
+    _originalInsetAdjustmentBehavior = [NSMapTable weakToStrongObjectsMapTable];
+    _pageKeys = @[];
+    _retainedPages = @"[]";
+    _currentIndex = 0;
+    _destinationIndex = 0;
+    _pendingInitialPage = 0;
+    _scrollEnabled = YES;
+    _hasAppliedInitialPage = NO;
+    _layoutDirection = @"ltr";
+
+    _containerView = [UIView new];
+    _containerView.clipsToBounds = YES;
+    self.contentView = _containerView;
+
+    [self initializePageViewController];
+  }
+  return self;
+}
+
+- (void)willMoveToSuperview:(UIView *)newSuperview
+{
+  [super willMoveToSuperview:newSuperview];
+  if (newSuperview != nil && _pageViewController == nil) {
+    self.contentView = _containerView;
+    [self initializePageViewController];
+  }
+}
+
+- (void)initializePageViewController
+{
+  _pageViewController = [[UIPageViewController alloc]
+    initWithTransitionStyle:UIPageViewControllerTransitionStyleScroll
+    navigationOrientation:UIPageViewControllerNavigationOrientationHorizontal
+    options:nil];
+  _pageViewController.dataSource = self;
+  _pageViewController.delegate = self;
+  [_containerView addSubview:_pageViewController.view];
+
+  for (UIView *subview in _pageViewController.view.subviews) {
+    if ([subview isKindOfClass:UIScrollView.class]) {
+      _pagerScrollView = (UIScrollView *)subview;
+      _pagerScrollView.delegate = self;
+      _pagerScrollView.delaysContentTouches = NO;
+      _pagerScrollView.scrollEnabled = _scrollEnabled;
+      break;
+    }
+  }
+}
+
+#pragma mark - React mounting
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                          index:(NSInteger)index
+{
+  if (_isBeingRecycled) return;
+  NSInteger safeIndex = MIN(MAX(index, 0), _logicalChildren.count);
+  [_logicalChildren insertObject:childComponentView atIndex:safeIndex];
+  [self rebuildSlots];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index
+{
+  if (_isBeingRecycled) return;
+  NSUInteger existingIndex = [_logicalChildren indexOfObjectIdenticalTo:childComponentView];
+  if (existingIndex == NSNotFound) return;
+  [childComponentView removeFromSuperview];
+  [_logicalChildren removeObjectAtIndex:existingIndex];
+  [self rebuildSlots];
+}
+
+- (void)rebuildSlots
+{
+  [self detachScrollObserver];
+  [_headerView removeFromSuperview];
+  [_stickyHeaderView removeFromSuperview];
+  _headerView = nil;
+  _stickyHeaderView = nil;
+  [_pageControllers removeAllObjects];
+
+  if (_logicalChildren.count > 0) {
+    _headerView = _logicalChildren[0];
+    [_containerView addSubview:_headerView];
+  }
+  if (_logicalChildren.count > 1) {
+    _stickyHeaderView = _logicalChildren[1];
+    [_containerView addSubview:_stickyHeaderView];
+  }
+  for (NSInteger index = 2; index < _logicalChildren.count; index++) {
+    UIView *page = _logicalChildren[index];
+    UIViewController *controller = [UIViewController new];
+    [controller.view addSubview:page];
+    [_pageControllers addObject:controller];
+  }
+
+  if (_pageControllers.count > 0) {
+    if (!_hasAppliedInitialPage &&
+        _pendingInitialPage >= 0 &&
+        _pendingInitialPage < _pageControllers.count) {
+      _currentIndex = _pendingInitialPage;
+      _hasAppliedInitialPage = YES;
+    } else {
+      _currentIndex = MIN(MAX(_currentIndex, 0), _pageControllers.count - 1);
+    }
+    UIViewController *controller = _pageControllers[_currentIndex];
+    [_pageViewController setViewControllers:@[controller]
+                                  direction:UIPageViewControllerNavigationDirectionForward
+                                   animated:NO
+                                 completion:nil];
+  }
+  if (_headerView != nil) [_containerView bringSubviewToFront:_headerView];
+  if (_stickyHeaderView != nil) [_containerView bringSubviewToFront:_stickyHeaderView];
+  [self setNeedsLayout];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self->_isBeingRecycled) {
+      [self prepareAdjacentPageInsets];
+      [self attachScrollObserverForCurrentPage];
+    }
+  });
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  _containerView.frame = self.bounds;
+  _pageViewController.view.frame = _containerView.bounds;
+  // UIKit frame assignment is undefined while a view has a non-identity transform.
+  // Lay out the original slots, then restore the shared collapse translation.
+  _headerView.transform = CGAffineTransformIdentity;
+  _stickyHeaderView.transform = CGAffineTransformIdentity;
+  _headerView.frame = CGRectMake(0, 0, self.bounds.size.width, _headerHeight);
+  _stickyHeaderView.frame = CGRectMake(
+    0,
+    _headerHeight,
+    self.bounds.size.width,
+    _stickyHeaderHeight
+  );
+  for (UIViewController *controller in _pageControllers) {
+    controller.view.frame = _pageViewController.view.bounds;
+    controller.view.subviews.firstObject.frame = controller.view.bounds;
+  }
+  [self applyHeaderOffset];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self->_isBeingRecycled) {
+      [self prepareAdjacentPageInsets];
+      [self attachScrollObserverForCurrentPage];
+    }
+  });
+}
+
+- (void)prepareForRecycle
+{
+  _isBeingRecycled = YES;
+  _generation++;
+  [self detachScrollObserver];
+  for (UIScrollView *scrollView in _originalInsets.keyEnumerator) {
+    NSValue *value = [_originalInsets objectForKey:scrollView];
+    if (value != nil) scrollView.contentInset = value.UIEdgeInsetsValue;
+    NSValue *indicatorValue = [_originalIndicatorInsets objectForKey:scrollView];
+    if (indicatorValue != nil) {
+      scrollView.verticalScrollIndicatorInsets = indicatorValue.UIEdgeInsetsValue;
+    }
+    NSNumber *alwaysBounce = [_originalAlwaysBounceVertical objectForKey:scrollView];
+    if (alwaysBounce != nil) scrollView.alwaysBounceVertical = alwaysBounce.boolValue;
+    NSNumber *adjustment = [_originalInsetAdjustmentBehavior objectForKey:scrollView];
+    if (adjustment != nil) {
+      scrollView.contentInsetAdjustmentBehavior = (UIScrollViewContentInsetAdjustmentBehavior)adjustment.integerValue;
+    }
+  }
+  [_originalInsets removeAllObjects];
+  [_originalIndicatorInsets removeAllObjects];
+  [_originalAlwaysBounceVertical removeAllObjects];
+  [_originalInsetAdjustmentBehavior removeAllObjects];
+  [_headerView removeFromSuperview];
+  [_stickyHeaderView removeFromSuperview];
+  [_logicalChildren removeAllObjects];
+  [_pageControllers removeAllObjects];
+  _headerView = nil;
+  _stickyHeaderView = nil;
+  _pageViewController.dataSource = nil;
+  _pageViewController.delegate = nil;
+  _pagerScrollView.delegate = nil;
+  [_pageViewController.view removeFromSuperview];
+  _pageViewController = nil;
+  _pagerScrollView = nil;
+  [super prepareForRecycle];
+  [_pageOffsets removeAllObjects];
+  _pageKeys = @[];
+  _retainedPages = @"[]";
+  _currentIndex = 0;
+  _destinationIndex = 0;
+  _pendingInitialPage = 0;
+  _headerHeight = 0;
+  _stickyHeaderHeight = 0;
+  _headerOffset = 0;
+  _scrollEnabled = YES;
+  _transitioning = NO;
+  _hasAppliedInitialPage = NO;
+  _layoutDirection = @"ltr";
+  _isBeingRecycled = NO;
+}
+
+#pragma mark - Props
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldViewProps = *std::static_pointer_cast<const RNCCollapsiblePagerViewProps>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<const RNCCollapsiblePagerViewProps>(props);
+
+  if (oldViewProps.initialPage != newViewProps.initialPage) {
+    _pendingInitialPage = MAX(0, newViewProps.initialPage);
+    _hasAppliedInitialPage = NO;
+  }
+  if (oldViewProps.scrollEnabled != newViewProps.scrollEnabled) {
+    _scrollEnabled = newViewProps.scrollEnabled;
+    _pagerScrollView.scrollEnabled = _scrollEnabled;
+  }
+  if (oldViewProps.layoutDirection != newViewProps.layoutDirection) {
+    _layoutDirection = RCTNSStringFromString(toString(newViewProps.layoutDirection));
+  }
+  BOOL insetsChanged = NO;
+  if (oldViewProps.headerHeight != newViewProps.headerHeight) {
+    _headerHeight = MAX(0, newViewProps.headerHeight);
+    _headerOffset = MIN(_headerOffset, _headerHeight);
+    insetsChanged = YES;
+  }
+  if (oldViewProps.stickyHeaderHeight != newViewProps.stickyHeaderHeight) {
+    _stickyHeaderHeight = MAX(0, newViewProps.stickyHeaderHeight);
+    insetsChanged = YES;
+  }
+  if (oldViewProps.pageKeys != newViewProps.pageKeys) {
+    NSString *json = RCTNSStringFromString(newViewProps.pageKeys);
+    NSData *data = [json dataUsingEncoding:NSUTF8StringEncoding];
+    id parsed = data == nil ? nil : [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+    _pageKeys = [parsed isKindOfClass:NSArray.class] ? parsed : @[];
+  }
+  if (oldViewProps.retainedPages != newViewProps.retainedPages) {
+    _retainedPages = RCTNSStringFromString(newViewProps.retainedPages);
+    [self setNeedsLayout];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+  if (insetsChanged) {
+    [self reapplyInsetsToObservedScrollView];
+    [self setNeedsLayout];
+  }
+}
+
+#pragma mark - Collapsible scroll coordination
+
+- (NSString *)currentPageKey
+{
+  return [self pageKeyForIndex:_currentIndex];
+}
+
+- (NSString *)pageKeyForIndex:(NSInteger)index
+{
+  if (index >= 0 && index < _pageKeys.count) return _pageKeys[index];
+  return [NSString stringWithFormat:@"page-%ld", (long)index];
+}
+
+- (UIScrollView *)findVerticalScrollViewInView:(UIView *)view
+{
+  if ([view isKindOfClass:UICollectionView.class]) {
+    UICollectionView *collectionView = (UICollectionView *)view;
+    UICollectionViewLayout *layout = collectionView.collectionViewLayout;
+    if (![layout isKindOfClass:UICollectionViewFlowLayout.class] ||
+        ((UICollectionViewFlowLayout *)layout).scrollDirection == UICollectionViewScrollDirectionVertical) {
+      return collectionView;
+    }
+  }
+  // Empty pages may use an RN ScrollView instead of a native row list.
+  if ([view isKindOfClass:UIScrollView.class] &&
+      ![view isKindOfClass:UICollectionView.class]) {
+    UIScrollView *scrollView = (UIScrollView *)view;
+    if (!scrollView.alwaysBounceHorizontal &&
+        scrollView.contentSize.width <= scrollView.bounds.size.width + 1) {
+      return scrollView;
+    }
+  }
+  for (UIView *subview in view.subviews) {
+    UIScrollView *candidate = [self findVerticalScrollViewInView:subview];
+    if (candidate != nil) return candidate;
+  }
+  return nil;
+}
+
+- (void)attachScrollObserverForCurrentPage
+{
+  [self restoreDetachedScrollInsets];
+  if (_currentIndex < 0 || _currentIndex >= _pageControllers.count) return;
+  UIScrollView *candidate = [self findVerticalScrollViewInView:_pageControllers[_currentIndex].view];
+  if (candidate == nil || candidate == _observedScrollView) return;
+
+  BOOL replacingCurrentScrollView = _observingContentOffset;
+  [self detachScrollObserver];
+  if (replacingCurrentScrollView) {
+    // A list replaced by an empty RN view keeps collapse, not the old row offset.
+    _pageOffsets[self.currentPageKey] = @(_headerOffset);
+  }
+  _observedScrollView = candidate;
+  [self applyInsetsToScrollView:candidate pageIndex:_currentIndex restore:YES];
+  [candidate addObserver:self
+              forKeyPath:@"contentOffset"
+                 options:NSKeyValueObservingOptionNew
+                 context:RNCCollapsiblePagerContentOffsetContext];
+  [candidate addObserver:self
+              forKeyPath:@"contentSize"
+                 options:NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew
+                 context:RNCCollapsiblePagerContentOffsetContext];
+  _observingContentOffset = YES;
+}
+
+- (void)detachScrollObserver
+{
+  UIScrollView *scrollView = _observedScrollView;
+  if (scrollView != nil) {
+    _pageOffsets[self.currentPageKey] = @(scrollView.contentOffset.y + scrollView.contentInset.top);
+    if (_observingContentOffset) {
+      [scrollView removeObserver:self
+                      forKeyPath:@"contentOffset"
+                         context:RNCCollapsiblePagerContentOffsetContext];
+      [scrollView removeObserver:self
+                      forKeyPath:@"contentSize"
+                         context:RNCCollapsiblePagerContentOffsetContext];
+    }
+  }
+  _observingContentOffset = NO;
+  _observedScrollView = nil;
+}
+
+- (void)restoreDetachedScrollInsets
+{
+  for (UIScrollView *scrollView in _originalInsets.keyEnumerator.allObjects) {
+    BOOL belongsToPage = NO;
+    for (UIViewController *controller in _pageControllers) {
+      if ([scrollView isDescendantOfView:controller.view]) {
+        belongsToPage = YES;
+        break;
+      }
+    }
+    if (belongsToPage) continue;
+    if (scrollView == _observedScrollView) {
+      [self detachScrollObserver];
+      _pageOffsets[self.currentPageKey] = @(_headerOffset);
+    }
+    // Fabric can reuse an empty RN ScrollView in another screen. Release all
+    // pager-owned insets before that view is used as a search or dialog list.
+    CGFloat logicalOffset = scrollView.contentOffset.y + scrollView.contentInset.top;
+    UIEdgeInsets original = [_originalInsets objectForKey:scrollView].UIEdgeInsetsValue;
+    scrollView.contentInset = original;
+    scrollView.verticalScrollIndicatorInsets =
+      [_originalIndicatorInsets objectForKey:scrollView].UIEdgeInsetsValue;
+    scrollView.alwaysBounceVertical =
+      [_originalAlwaysBounceVertical objectForKey:scrollView].boolValue;
+    scrollView.contentInsetAdjustmentBehavior = (UIScrollViewContentInsetAdjustmentBehavior)
+      [_originalInsetAdjustmentBehavior objectForKey:scrollView].integerValue;
+    [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, logicalOffset - original.top)
+                       animated:NO];
+    [_originalInsets removeObjectForKey:scrollView];
+    [_originalIndicatorInsets removeObjectForKey:scrollView];
+    [_originalAlwaysBounceVertical removeObjectForKey:scrollView];
+    [_originalInsetAdjustmentBehavior removeObjectForKey:scrollView];
+  }
+}
+
+- (void)applyInsetsToScrollView:(UIScrollView *)scrollView
+                      pageIndex:(NSInteger)pageIndex
+                        restore:(BOOL)restore
+{
+  NSValue *storedOriginal = [_originalInsets objectForKey:scrollView];
+  UIEdgeInsets original = storedOriginal == nil
+    ? scrollView.contentInset
+    : storedOriginal.UIEdgeInsetsValue;
+  if (storedOriginal == nil) {
+    [_originalInsets setObject:[NSValue valueWithUIEdgeInsets:original] forKey:scrollView];
+    [_originalIndicatorInsets
+      setObject:[NSValue valueWithUIEdgeInsets:scrollView.verticalScrollIndicatorInsets]
+      forKey:scrollView];
+    [_originalAlwaysBounceVertical setObject:@(scrollView.alwaysBounceVertical) forKey:scrollView];
+    [_originalInsetAdjustmentBehavior setObject:@(scrollView.contentInsetAdjustmentBehavior) forKey:scrollView];
+  }
+
+  // This host already includes the fixed header and safe area in its frame.
+  // UIKit automatic adjustment would add them a second time to short pages.
+  scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+  CGFloat previousLogicalOffset = scrollView.contentOffset.y + scrollView.contentInset.top;
+  UIEdgeInsets next = original;
+  next.top += _headerHeight + _stickyHeaderHeight;
+  // Short pages still need enough range to collapse the header; long pages
+  // must end at the last row rather than leave a header-sized blank footer.
+  next.bottom += MAX(0, scrollView.bounds.size.height - _stickyHeaderHeight
+    - original.top - original.bottom - scrollView.contentSize.height);
+  if (UIEdgeInsetsEqualToEdgeInsets(scrollView.contentInset, next) && !restore) {
+    // UICollectionView may report contentSize during a bounce without changing
+    // the required insets. Re-setting contentOffset here interrupts that bounce.
+    if (pageIndex == _currentIndex) [self updateHeaderForScrollView:scrollView];
+    return;
+  }
+  scrollView.contentInset = next;
+  UIEdgeInsets indicatorInsets = scrollView.verticalScrollIndicatorInsets;
+  indicatorInsets.top = next.top;
+  scrollView.verticalScrollIndicatorInsets = indicatorInsets;
+  scrollView.alwaysBounceVertical = YES;
+
+  CGFloat targetOffset = previousLogicalOffset - next.top;
+  if (restore) {
+    NSNumber *saved = _pageOffsets[[self pageKeyForIndex:pageIndex]];
+    // The sticky slot can change height between pages. Cache offsets relative
+    // to content start so a round trip does not add that height difference.
+    targetOffset = (saved == nil ? _headerOffset : saved.doubleValue) - next.top;
+    targetOffset = MAX(targetOffset, -next.top + _headerOffset);
+  }
+  [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, targetOffset) animated:NO];
+  if (pageIndex == _currentIndex) [self updateHeaderForScrollView:scrollView];
+}
+
+- (void)reapplyInsetsToObservedScrollView
+{
+  [self restoreDetachedScrollInsets];
+  UIScrollView *scrollView = _observedScrollView;
+  if (scrollView != nil) {
+    [self applyInsetsToScrollView:scrollView pageIndex:_currentIndex restore:NO];
+  }
+  [self prepareAdjacentPageInsets];
+}
+
+- (void)prepareAdjacentPageInsets
+{
+  [self restoreDetachedScrollInsets];
+  NSInteger first = MAX(0, _currentIndex - 1);
+  NSInteger last = MIN((NSInteger)_pageControllers.count - 1, _currentIndex + 1);
+  if (last < first) return;
+  for (NSInteger index = first; index <= last; index++) {
+    UIScrollView *scrollView = [self findVerticalScrollViewInView:_pageControllers[index].view];
+    if (scrollView != nil && scrollView != _observedScrollView) {
+      [self applyInsetsToScrollView:scrollView pageIndex:index restore:YES];
+    }
+  }
+}
+
+- (void)observeValueForKeyPath:(NSString *)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary<NSKeyValueChangeKey,id> *)change
+                       context:(void *)context
+{
+  if (context == RNCCollapsiblePagerContentOffsetContext && object == _observedScrollView) {
+    if ([keyPath isEqualToString:@"contentSize"]) {
+      NSValue *oldSize = change[NSKeyValueChangeOldKey];
+      NSValue *newSize = change[NSKeyValueChangeNewKey];
+      if (![oldSize isEqual:newSize]) {
+        [self applyInsetsToScrollView:_observedScrollView pageIndex:_currentIndex restore:NO];
+      }
+      return;
+    }
+    UIScrollView *scrollView = (UIScrollView *)object;
+    _pageOffsets[self.currentPageKey] = @(scrollView.contentOffset.y + scrollView.contentInset.top);
+    [self updateHeaderForScrollView:scrollView];
+    return;
+  }
+  [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+}
+
+- (void)updateHeaderForScrollView:(UIScrollView *)scrollView
+{
+  CGFloat logicalOffset = scrollView.contentOffset.y + scrollView.contentInset.top;
+  _headerOffset = MIN(MAX(logicalOffset, 0), _headerHeight);
+  [self applyHeaderOffset];
+}
+
+- (void)applyHeaderOffset
+{
+  CGAffineTransform transform = CGAffineTransformMakeTranslation(0, -_headerOffset);
+  _headerView.transform = transform;
+  _stickyHeaderView.transform = transform;
+}
+
+#pragma mark - Pager navigation
+
+- (BOOL)isLtrLayout
+{
+  return [_layoutDirection isEqualToString:@"ltr"];
+}
+
+- (void)goTo:(NSInteger)index animated:(BOOL)animated
+{
+  if (_isBeingRecycled || index < 0 || index >= _pageControllers.count) return;
+  if (_transitioning && animated) return;
+
+  [self detachScrollObserver];
+  _destinationIndex = index;
+  BOOL forward = (index > _currentIndex && self.isLtrLayout) ||
+    (index < _currentIndex && !self.isLtrLayout);
+  UIPageViewControllerNavigationDirection direction = forward
+    ? UIPageViewControllerNavigationDirectionForward
+    : UIPageViewControllerNavigationDirectionReverse;
+  _transitioning = YES;
+  NSUInteger capturedGeneration = _generation;
+  __weak __typeof__(self) weakSelf = self;
+  [_pageViewController setViewControllers:@[_pageControllers[index]]
+                                direction:direction
+                                 animated:animated && index != _currentIndex
+                               completion:^(BOOL finished) {
+    __strong __typeof__(weakSelf) self = weakSelf;
+    if (self == nil || self->_generation != capturedGeneration || self->_isBeingRecycled) return;
+    self->_transitioning = NO;
+    self->_currentIndex = index;
+    [self attachScrollObserverForCurrentPage];
+    [self emitPageSelected:index];
+    [self emitDiagnostics:@"page-selected"];
+  }];
+}
+
+- (UIViewController *)adjacentController:(UIViewController *)controller delta:(NSInteger)delta
+{
+  NSInteger index = [_pageControllers indexOfObjectIdenticalTo:controller];
+  if (index == NSNotFound) return nil;
+  NSInteger target = index + delta;
+  if (target < 0 || target >= _pageControllers.count) return nil;
+  UIScrollView *scrollView = [self findVerticalScrollViewInView:_pageControllers[target].view];
+  if (scrollView != nil) {
+    [self applyInsetsToScrollView:scrollView pageIndex:target restore:YES];
+  }
+  return _pageControllers[target];
+}
+
+- (UIViewController *)pageViewController:(UIPageViewController *)pageViewController
+      viewControllerAfterViewController:(UIViewController *)viewController
+{
+  return [self adjacentController:viewController delta:self.isLtrLayout ? 1 : -1];
+}
+
+- (UIViewController *)pageViewController:(UIPageViewController *)pageViewController
+     viewControllerBeforeViewController:(UIViewController *)viewController
+{
+  return [self adjacentController:viewController delta:self.isLtrLayout ? -1 : 1];
+}
+
+- (void)pageViewController:(UIPageViewController *)pageViewController
+        didFinishAnimating:(BOOL)finished
+   previousViewControllers:(NSArray<UIViewController *> *)previousViewControllers
+       transitionCompleted:(BOOL)completed
+{
+  _transitioning = NO;
+  if (!completed) return;
+  UIViewController *controller = _pageViewController.viewControllers.firstObject;
+  NSInteger index = [_pageControllers indexOfObjectIdenticalTo:controller];
+  if (index == NSNotFound) return;
+  [self detachScrollObserver];
+  _currentIndex = index;
+  [self attachScrollObserverForCurrentPage];
+  [self emitPageSelected:index];
+  [self emitDiagnostics:@"page-selected"];
+}
+
+#pragma mark - Pager UIScrollViewDelegate
+
+- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
+{
+  const auto emitter = [self eventEmitter];
+  if (emitter) {
+    emitter->onPageScrollStateChanged({
+      .pageScrollState = RNCCollapsiblePagerViewEventEmitter::OnPageScrollStateChangedPageScrollState::Dragging
+    });
+  }
+}
+
+- (void)scrollViewWillEndDragging:(UIScrollView *)scrollView
+                     withVelocity:(CGPoint)velocity
+              targetContentOffset:(inout CGPoint *)targetContentOffset
+{
+  const auto emitter = [self eventEmitter];
+  if (emitter) {
+    emitter->onPageScrollStateChanged({
+      .pageScrollState = RNCCollapsiblePagerViewEventEmitter::OnPageScrollStateChangedPageScrollState::Settling
+    });
+  }
+}
+
+- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
+{
+  const auto emitter = [self eventEmitter];
+  if (emitter) {
+    emitter->onPageScrollStateChanged({
+      .pageScrollState = RNCCollapsiblePagerViewEventEmitter::OnPageScrollStateChangedPageScrollState::Idle
+    });
+  }
+  [self emitDiagnostics:@"pager-idle"];
+}
+
+- (void)scrollViewDidScroll:(UIScrollView *)scrollView
+{
+  CGFloat width = scrollView.bounds.size.width;
+  if (width <= 0) return;
+  CGFloat rawOffset = (scrollView.contentOffset.x - width) / width;
+  BOOL backwards = self.isLtrLayout ? rawOffset < 0 : rawOffset > 0;
+  NSInteger position = backwards ? _currentIndex - 1 : _currentIndex;
+  CGFloat offset = backwards ? 1 - fabs(rawOffset) : fabs(rawOffset);
+  position = MAX(0, MIN(position, (NSInteger)_pageControllers.count - 1));
+  const auto emitter = [self eventEmitter];
+  if (emitter) {
+    emitter->onPageScroll({.position = (double)position, .offset = (double)offset});
+  }
+}
+
+#pragma mark - Events and commands
+
+- (std::shared_ptr<const RNCCollapsiblePagerViewEventEmitter>)eventEmitter
+{
+  if (!_eventEmitter) return nullptr;
+  return std::static_pointer_cast<const RNCCollapsiblePagerViewEventEmitter>(_eventEmitter);
+}
+
+- (void)emitPageSelected:(NSInteger)position
+{
+  const auto emitter = [self eventEmitter];
+  if (emitter) emitter->onPageSelected({.position = (double)position});
+}
+
+- (void)emitDiagnostics:(NSString *)reason
+{
+  const auto emitter = [self eventEmitter];
+  if (!emitter) return;
+  NSInteger attached = 0;
+  for (UIViewController *controller in _pageControllers) {
+    if (controller.view.superview != nil) attached++;
+  }
+  emitter->onCollapsibleStateChanged({
+    .position = (int)_currentIndex,
+    .headerOffset = (double)_headerOffset,
+    .nativePageCount = (int)_pageControllers.count,
+    .attachedPageCount = (int)attached,
+    .observedScrollableCount = (int)_originalInsets.count,
+    .retainedPages = std::string(_retainedPages.UTF8String ?: "[]"),
+    .reason = std::string(reason.UTF8String ?: "unknown")
+  });
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTRNCCollapsiblePagerViewHandleCommand(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;
+  _pagerScrollView.scrollEnabled = scrollEnabled;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNCCollapsiblePagerViewComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNCCollapsiblePagerViewCls(void)
+{
+  return RNCCollapsiblePagerViewComponentView.class;
+}