@onekeyfe/react-native-pager-view 3.0.157-alpha.257 → 3.0.157-alpha.262

package/ios/tests/RNCCollapsiblePagerPressCancellationWiringTests.mm

@@ -0,0 +1,109 @@
+#import <XCTest/XCTest.h>
+#import <React/RCTSurfaceTouchHandler.h>
+
+#import "RNCCollapsiblePagerViewComponentView.h"
+#import <react/renderer/components/pagerview/Props.h>
+
+using namespace facebook::react;
+
+@interface RNCPressWiringTestTouch : UITouch
+@property (nonatomic, strong) UIView *testView;
+@end
+@implementation RNCPressWiringTestTouch
+- (UIView *)view { return self.testView; }
+@end
+
+@interface RNCCollapsiblePagerPressCancellationWiringTests : XCTestCase
+@property (nonatomic, strong) UIWindow *window;
+@property (nonatomic, strong) UIView *host;
+@property (nonatomic, strong) UIView *surface;
+@property (nonatomic, strong) RCTSurfaceTouchHandler *handler;
+@property (nonatomic, strong) RNCCollapsiblePagerViewComponentView *pager;
+@end
+
+@implementation RNCCollapsiblePagerPressCancellationWiringTests
+
+- (void)setUp
+{
+  [super setUp];
+  // Window membership installs the bridge without presenting or taking focus.
+  self.window = [[UIWindow alloc] initWithFrame:CGRectMake(0, 0, 320, 600)];
+  self.host = [[UIView alloc] initWithFrame:self.window.bounds];
+  self.surface = [[UIView alloc] initWithFrame:self.host.bounds];
+  [self.window addSubview:self.host];
+  [self.host addSubview:self.surface];
+  self.handler = [RCTSurfaceTouchHandler new];
+  [self.handler attachToView:self.surface];
+  self.pager = [[RNCCollapsiblePagerViewComponentView alloc] init];
+  auto props = std::make_shared<RNCCollapsiblePagerViewProps>();
+  props->nativeSmoothHeaderScrollEnabled = true;
+  [self.pager updateProps:props oldProps:nullptr];
+  self.pager.frame = self.surface.bounds;
+  [self.surface addSubview:self.pager];
+}
+
+- (void)tearDown
+{
+  [self.pager removeFromSuperview];
+  [self.handler detachFromView:self.surface];
+  self.pager = nil;
+  self.handler = nil;
+  self.surface = nil;
+  self.host = nil;
+  self.window = nil;
+  [super tearDown];
+}
+
+- (void)testInstalledBridgeCancelsTouchesAndFiltersItsContentScope
+{
+  UIGestureRecognizer *bridge = [self.pager valueForKey:@"contentPressCancellationGesture"];
+  XCTAssertNotNil(bridge);
+  XCTAssertTrue([bridge isKindOfClass:NSClassFromString(@"RNCCollapsiblePagerContentPressCancellationGestureRecognizer")]);
+  XCTAssertEqual(bridge.view, self.host);
+  XCTAssertEqual([bridge valueForKey:@"reactTouchHandler"], self.handler);
+  XCTAssertTrue(bridge.cancelsTouchesInView);
+  XCTAssertFalse(bridge.delaysTouchesBegan);
+  XCTAssertFalse(bridge.delaysTouchesEnded);
+  XCTAssertTrue([self.handler canBePreventedByGestureRecognizer:bridge]);
+
+  UIScrollView *scrollView = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertNotNil(scrollView);
+  UIView *content = [UIView new];
+  [scrollView addSubview:content];
+  UIView *header = [self.pager valueForKey:@"sharedHeaderHostView"];
+  // Smooth mode reparents the shared header into the same content subtree.
+  [scrollView addSubview:header];
+  UIView *headerButton = [UIView new];
+  [header addSubview:headerButton];
+  RNCPressWiringTestTouch *touch = [RNCPressWiringTestTouch new];
+  id<UIGestureRecognizerDelegate> delegate = bridge.delegate;
+  XCTAssertEqual((id)delegate, self.pager);
+  touch.testView = content;
+  XCTAssertTrue([delegate gestureRecognizer:bridge shouldReceiveTouch:touch]);
+  touch.testView = headerButton;
+  XCTAssertFalse([delegate gestureRecognizer:bridge shouldReceiveTouch:touch]);
+  touch.testView = self.surface;
+  XCTAssertFalse([delegate gestureRecognizer:bridge shouldReceiveTouch:touch]);
+}
+
+- (void)testWindowDetachUnbindsInstalledBridge
+{
+  UIGestureRecognizer *bridge = [self.pager valueForKey:@"contentPressCancellationGesture"];
+  XCTAssertNotNil(bridge);
+  [self.pager removeFromSuperview];
+  XCTAssertNil(bridge.view);
+  XCTAssertNil([bridge valueForKey:@"reactTouchHandler"]);
+  XCTAssertNil([self.pager valueForKey:@"contentPressCancellationGesture"]);
+}
+
+- (void)testRecycleUnbindsInstalledBridge
+{
+  UIGestureRecognizer *bridge = [self.pager valueForKey:@"contentPressCancellationGesture"];
+  XCTAssertNotNil(bridge);
+  [self.pager prepareForRecycle];
+  XCTAssertNil(bridge.view);
+  XCTAssertNil([bridge valueForKey:@"reactTouchHandler"]);
+  XCTAssertNil([self.pager valueForKey:@"contentPressCancellationGesture"]);
+}
+
+@end

package/ios/tests/RNCNativeScrollerTests.mm

@@ -0,0 +1,252 @@
+#import <XCTest/XCTest.h>
+#import "RNCNativeScrollerComponentView.h"
+#import "RNCCollapsiblePagerViewComponentView.h"
+#import <react/renderer/components/pagerview/Props.h>
+
+using namespace facebook::react;
+
+@interface RNCNativeScrollerComponentView (Tests)
+- (void)emitScrollEvent:(NSInteger)kind velocity:(CGPoint)velocity target:(CGPoint)target;
+- (void)clampContentOffsetIfNeeded;
+- (void)scrollTo:(double)x y:(double)y animated:(BOOL)animated;
+- (void)setRefreshing:(BOOL)refreshing;
+- (CGFloat)contentViewportHeight;
+@end
+
+@interface RNCCollapsiblePagerViewComponentView (ScrollerTests)
+- (void)applyInsetsToScrollView:(UIScrollView *)scrollView pageIndex:(NSInteger)index restore:(BOOL)restore;
+- (void)restoreScrollViewState:(UIScrollView *)scrollView resetSavedOffset:(BOOL)reset;
+@end
+
+@interface RNCObservedScroller : RNCNativeScrollerComponentView
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *events;
+@end
+@implementation RNCObservedScroller
+- (void)emitScrollEvent:(NSInteger)kind velocity:(CGPoint)velocity target:(CGPoint)target
+{
+  if (self.events == nil) self.events = [NSMutableArray new];
+  [self.events addObject:@(kind)];
+  [super emitScrollEvent:kind velocity:velocity target:target];
+}
+@end
+
+@interface RNCNativeScrollerTests : XCTestCase
+@property (nonatomic, strong) RNCObservedScroller *scroller;
+@end
+@implementation RNCNativeScrollerTests
+
+- (void)setUp
+{
+  [super setUp];
+  self.scroller = [RNCObservedScroller new];
+  LayoutMetrics metrics;
+  metrics.frame.size = {320, 600};
+  [self.scroller updateLayoutMetrics:metrics oldLayoutMetrics:{}];
+}
+
+- (void)tearDown
+{
+  [self.scroller prepareForRecycle];
+  self.scroller = nil;
+  [super tearDown];
+}
+
+- (void)testContentSizeDoesNotRelayoutReactContentOrSharedHeader
+{
+  RCTViewComponentView *content = [RCTViewComponentView new];
+  content.frame = CGRectMake(0, 0, 320, 900);
+  [self.scroller mountChildComponentView:content index:0];
+  UIView *header = [[UIView alloc] initWithFrame:CGRectMake(0, -200, 320, 200)];
+  [self.scroller.scrollView addSubview:header];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->contentWidth = 320;
+  props->contentHeight = 900;
+  [self.scroller updateProps:props oldProps:nullptr];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentSize.height, 900, 0.01);
+  XCTAssertTrue(CGRectEqualToRect(content.frame, CGRectMake(0, 0, 320, 900)));
+  XCTAssertTrue(CGRectEqualToRect(header.frame, CGRectMake(0, -200, 320, 200)));
+  XCTAssertEqual(header.superview, self.scroller.scrollView);
+  XCTAssertFalse([self.scroller.scrollView isKindOfClass:NSClassFromString(@"RCTEnhancedScrollView")]);
+}
+
+- (void)testShrinkClampsOnlyUnreachableUpperOffset
+{
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->contentWidth = 320;
+  props->contentHeight = 1500;
+  [self.scroller updateProps:props oldProps:nullptr];
+  self.scroller.scrollView.contentInset = UIEdgeInsetsMake(200, 0, 468, 0);
+  self.scroller.scrollView.contentOffset = CGPointMake(0, 800);
+  auto shorter = std::make_shared<RNCNativeScrollerProps>();
+  shorter->contentWidth = 320;
+  shorter->contentHeight = 132;
+  [self.scroller updateProps:shorter oldProps:props];
+  [self.scroller clampContentOffsetIfNeeded];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentOffset.y, 0, 0.01);
+  self.scroller.scrollView.contentOffset = CGPointMake(0, -240);
+  auto empty = std::make_shared<RNCNativeScrollerProps>();
+  empty->contentWidth = 320;
+  empty->contentHeight = 0;
+  [self.scroller updateProps:empty oldProps:shorter];
+  [self.scroller clampContentOffsetIfNeeded];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentOffset.y, -240, 0.01);
+}
+
+- (void)testNativeInterruptionEndsEachDragAndMomentumOnlyOnce
+{
+  UIScrollView *scroll = self.scroller.scrollView;
+  id<UIScrollViewDelegate> delegate = scroll.delegate;
+  [delegate scrollViewWillBeginDragging:scroll];
+  [self.scroller stopScrolling];
+  [delegate scrollViewDidEndDragging:scroll willDecelerate:NO];
+  XCTAssertEqualObjects(self.scroller.events, (@[@1, @2]));
+  [self.scroller.events removeAllObjects];
+  [delegate scrollViewWillBeginDecelerating:scroll];
+  [self.scroller stopScrolling];
+  [delegate scrollViewDidEndDecelerating:scroll];
+  NSPredicate *terminal = [NSPredicate predicateWithFormat:@"SELF == 4"];
+  XCTAssertEqual([self.scroller.events filteredArrayUsingPredicate:terminal].count, 1u);
+  XCTAssertEqualObjects(self.scroller.events.firstObject, @3);
+}
+
+- (void)testRefreshReplacementAndRecycleDoNotKeepOldControl
+{
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->refreshEnabled = true;
+  props->refreshProgressViewOffset = 24;
+  [self.scroller updateProps:props oldProps:nullptr];
+  UIRefreshControl *original = self.scroller.scrollView.refreshControl;
+  XCTAssertNotNil(original);
+  XCTAssertEqualWithAccuracy(original.bounds.origin.y, -24, 0.01);
+  [self.scroller prepareForRecycle];
+  XCTAssertNil(self.scroller.scrollView.refreshControl);
+  [self.scroller updateProps:props oldProps:props];
+  XCTAssertNotNil(self.scroller.scrollView.refreshControl);
+  XCTAssertNotEqual(self.scroller.scrollView.refreshControl, original);
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.refreshControl.bounds.origin.y, -24, 0.01);
+  [self.scroller setRefreshing:NO];
+  XCTAssertFalse(self.scroller.scrollView.refreshControl.refreshing);
+}
+
+- (void)testCallerInsetUpdatesSurvivePagerReapplyAndRelease
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  auto pagerProps = std::make_shared<RNCCollapsiblePagerViewProps>();
+  pagerProps->headerHeight = 120;
+  pagerProps->stickyHeaderHeight = 40;
+  [pager updateProps:pagerProps oldProps:nullptr];
+  [pager addSubview:self.scroller];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->contentWidth = 320;
+  props->contentHeight = 1500;
+  props->contentInsetTop = 10;
+  [self.scroller updateProps:props oldProps:nullptr];
+  [pager applyInsetsToScrollView:self.scroller.scrollView pageIndex:0 restore:NO];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentInset.top, 170, 0.01);
+  auto updated = std::make_shared<RNCNativeScrollerProps>();
+  updated->contentWidth = 320;
+  updated->contentHeight = 1500;
+  updated->contentInsetTop = 30;
+  updated->contentInsetBottom = 20;
+  [self.scroller updateProps:updated oldProps:props];
+  [pager applyInsetsToScrollView:self.scroller.scrollView pageIndex:0 restore:NO];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentInset.top, 190, 0.01);
+  [pager restoreScrollViewState:self.scroller.scrollView resetSavedOffset:YES];
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentInset.top, 30, 0.01);
+  XCTAssertEqualWithAccuracy(self.scroller.scrollView.contentInset.bottom, 20, 0.01);
+  [self.scroller removeFromSuperview];
+}
+
+- (void)testRecycledDelegateCannotStartASequenceForTheNextOwner
+{
+  UIScrollView *scroll = self.scroller.scrollView;
+  id<UIScrollViewDelegate> oldDelegate = scroll.delegate;
+  [self.scroller prepareForRecycle];
+  XCTAssertNil(scroll.delegate);
+  [oldDelegate scrollViewWillBeginDragging:scroll];
+  [oldDelegate scrollViewWillBeginDecelerating:scroll];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  [self.scroller updateProps:props oldProps:nullptr];
+  XCTAssertEqual(scroll.delegate, self.scroller);
+  [self.scroller stopScrolling];
+  NSPredicate *terminal = [NSPredicate predicateWithFormat:@"SELF == 2 OR SELF == 4"];
+  XCTAssertEqual([self.scroller.events filteredArrayUsingPredicate:terminal].count, 0u);
+}
+
+- (void)testPagerExplicitlyFindsIndependentScrollView
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  UIView *page = [UIView new];
+  [page addSubview:self.scroller];
+  SEL finder = NSSelectorFromString(@"findExplicitNativeScrollerInView:");
+  UIScrollView *(*find)(id, SEL, UIView *) =
+    (UIScrollView *(*)(id, SEL, UIView *))[pager methodForSelector:finder];
+  XCTAssertEqual(find(pager, finder, page), self.scroller.scrollView);
+}
+
+- (void)testContentViewportUsesOnlyCallerInsetsAndStaticStickyHeight
+{
+  RNCCollapsiblePagerViewComponentView *pager = [RNCCollapsiblePagerViewComponentView new];
+  auto pagerProps = std::make_shared<RNCCollapsiblePagerViewProps>();
+  pagerProps->headerHeight = 120;
+  pagerProps->stickyHeaderHeight = 40;
+  [pager updateProps:pagerProps oldProps:nullptr];
+  [pager addSubview:self.scroller];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  props->contentWidth = 320;
+  props->contentHeight = 20;
+  props->contentInsetTop = 10;
+  props->contentInsetBottom = 20;
+  [self.scroller updateProps:props oldProps:nullptr];
+  [pager applyInsetsToScrollView:self.scroller.scrollView pageIndex:0 restore:NO];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 530, 0.01);
+  // Synthetic bottom fill and temporary refresh insets are not caller geometry.
+  self.scroller.scrollView.contentInset = UIEdgeInsetsMake(230, 0, 510, 0);
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 530, 0.01);
+  auto filled = std::make_shared<RNCNativeScrollerProps>();
+  filled->contentWidth = 320;
+  filled->contentHeight = 530;
+  filled->contentInsetTop = 10;
+  filled->contentInsetBottom = 20;
+  [self.scroller updateProps:filled oldProps:props];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 530, 0.01);
+  LayoutMetrics metrics;
+  metrics.frame.size = {320, 700};
+  [self.scroller updateLayoutMetrics:metrics oldLayoutMetrics:{}];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 630, 0.01);
+  auto updated = std::make_shared<RNCNativeScrollerProps>();
+  updated->contentWidth = 320;
+  updated->contentHeight = 530;
+  updated->contentInsetTop = 10;
+  updated->contentInsetBottom = 30;
+  [self.scroller updateProps:updated oldProps:filled];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 620, 0.01);
+  auto tallerSticky = std::make_shared<RNCCollapsiblePagerViewProps>();
+  tallerSticky->headerHeight = 250;
+  tallerSticky->stickyHeaderHeight = 60;
+  [pager updateProps:tallerSticky oldProps:pagerProps];
+  [pager applyInsetsToScrollView:self.scroller.scrollView pageIndex:0 restore:NO];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 600, 0.01);
+  [pager restoreScrollViewState:self.scroller.scrollView resetSavedOffset:YES];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 660, 0.01);
+  [self.scroller removeFromSuperview];
+}
+
+- (void)testContentViewportReleasesIndependentPagerContributions
+{
+  NSObject *outer = [NSObject new];
+  NSObject *inner = [NSObject new];
+  [self.scroller setPagerStickyHeight:40 forOwner:outer];
+  [self.scroller setPagerStickyHeight:20 forOwner:inner];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 540, 0.01);
+  [self.scroller setPagerStickyHeight:40 forOwner:outer];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 540, 0.01);
+  [self.scroller setPagerStickyHeight:0 forOwner:outer];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 580, 0.01);
+  [self.scroller prepareForRecycle];
+  auto props = std::make_shared<RNCNativeScrollerProps>();
+  [self.scroller updateProps:props oldProps:nullptr];
+  XCTAssertEqualWithAccuracy([self.scroller contentViewportHeight], 600, 0.01);
+}
+
+@end

package/lib/module/CollapsiblePagerView.js

@@ -30,6 +30,10 @@ export class CollapsiblePagerView extends React.PureComponent {
   lastMountSignature = null;
   nativeTabCommandId = 0;
   latestNativeTabTarget = null;
+
+  // Target of the last tab command native has received and not yet reported
+  // as selected. Commands superseded before their frame never reach native.
+  dispatchedNativeTabTarget = null;
   latestNativeSelectedPage = this.state.selectedPage;
   nativePagerScrollState = "idle";
   nativeTabCommandQueuedDuringScroll = false;
@@ -89,6 +93,7 @@ export class CollapsiblePagerView extends React.PureComponent {
         if (commandId !== this.nativeTabCommandId || !this.nativeRef) {
           return;
         }
+        this.dispatchedNativeTabTarget = position;
         if (animated) {
           CollapsiblePagerViewNativeCommands.setPage(this.nativeRef, position);
         } else {
@@ -136,6 +141,7 @@ export class CollapsiblePagerView extends React.PureComponent {
       const transitionComplete = pendingTarget === position;
       if (transitionComplete) {
         this.latestNativeTabTarget = null;
+        this.dispatchedNativeTabTarget = null;
         this.nativeTabCommandQueuedDuringScroll = false;
       }
       this.setState({
@@ -154,6 +160,7 @@ export class CollapsiblePagerView extends React.PureComponent {
     if (scrollState === "idle" && this.latestNativeTabTarget !== null && this.latestNativeTabTarget !== this.latestNativeSelectedPage && !queuedDuringPreviousScroll) {
       ++this.nativeTabCommandId;
       this.latestNativeTabTarget = null;
+      this.dispatchedNativeTabTarget = null;
       this.setState({
         transientRetainedPages: []
       }, this.notifyMountedPagesChanged);
@@ -166,7 +173,9 @@ export class CollapsiblePagerView extends React.PureComponent {
   onNativeTabPress = event => {
     const position = pageIndex(event.nativeEvent.position);
     if (position !== null && position >= 0 && position < this.pages().length && (position !== this.state.selectedPage || this.latestNativeTabTarget !== null)) {
-      this.dispatchNativeTabPageCommand(position, this.props.nativeTabPressAnimationEnabled ?? true);
+      // Selection state lags an in-flight transition until native reports it.
+      const currentPage = this.dispatchedNativeTabTarget ?? this.state.selectedPage;
+      this.dispatchNativeTabPageCommand(position, this.props.nativeTabPressAnimationEnabled ?? Math.abs(position - currentPage) <= 1);
     }
     this.props.onNativeTabPress?.(event);
   };

package/lib/module/NativeScroller.js

@@ -1,25 +1,185 @@
 "use strict";
 
 import * as React from "react";
-import { ScrollView } from "react-native";
+import { findNodeHandle, Keyboard, Platform, StyleSheet, TextInput, View } from "react-native";
+import NativeScrollerHost, { Commands } from "./NativeScrollerNativeComponent";
 import { jsx as _jsx } from "react/jsx-runtime";
 export const NATIVE_SCROLLER_NATIVE_ID_PREFIX = "rnc-collapsible-pager-native-scroller";
-/**
- * Primary non-virtualized vertical scroller for a CollapsiblePagerView page.
- */
+
+/** Supported vertical subset; horizontal, snapping, zoom and sticky rows are not supported. */
+
+// The RN 0.86 JS registry distinguishes another input from an unhandled tap.
+// TextInput.State's public facade does not export this query.
+const textInputState = require("react-native/Libraries/Components/TextInput/TextInputState").default;
+const styles = StyleSheet.create({
+  viewport: {
+    flexGrow: 1,
+    flexShrink: 1,
+    overflow: "hidden"
+  },
+  content: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    flexShrink: 0
+  }
+});
 export const NativeScroller = /*#__PURE__*/React.forwardRef(function NativeScroller({
+  children,
   nativeID,
-  nestedScrollEnabled = true,
   pagerScrollKey,
+  style,
+  contentContainerStyle,
+  onLayout,
+  onContentSizeChange,
+  refreshControl,
+  nestedScrollEnabled = true,
+  contentInset,
+  decelerationRate = "normal",
+  keyboardShouldPersistTaps = "never",
+  onScroll,
+  onScrollBeginDrag,
+  onMomentumScrollBegin,
+  onMomentumScrollEnd,
+  onStartShouldSetResponder,
+  onStartShouldSetResponderCapture,
+  onResponderGrant,
+  onResponderRelease,
+  onResponderTerminationRequest,
   ...props
-}, ref) {
+}, forwardedRef) {
+  const hostRef = React.useRef(null);
   const generatedId = React.useId();
-  const scrollKey = pagerScrollKey ?? nativeID ?? generatedId;
-  return /*#__PURE__*/_jsx(ScrollView, {
+  const [contentViewportHeight, setContentViewportHeight] = React.useState(0);
+  const [contentSize, setContentSize] = React.useState({
+    width: 0,
+    height: 0
+  });
+  const [refreshEpoch, requestRefreshSync] = React.useReducer(value => value + 1, 0);
+  const contentSizeRef = React.useRef(contentSize);
+  const scrolledSinceGrant = React.useRef(false);
+  const momentum = React.useRef(false);
+  const grantedDuringMomentum = React.useRef(false);
+  const persistTaps = keyboardShouldPersistTaps === true ? "always" : keyboardShouldPersistTaps === false ? "never" : keyboardShouldPersistTaps;
+  const contentStyle = StyleSheet.flatten(contentContainerStyle);
+  const refresh = refreshControl?.props;
+  const rate = typeof decelerationRate === "number" ? decelerationRate : decelerationRate === "fast" ? Platform.OS === "ios" ? 0.99 : 0.9 : Platform.OS === "ios" ? 0.998 : 0.985;
+  React.useEffect(() => {
+    if (hostRef.current) Commands.setRefreshState(hostRef.current, refresh?.refreshing ?? false);
+  }, [refresh?.refreshing, refreshEpoch]);
+  React.useImperativeHandle(forwardedRef, () => ({
+    scrollTo(options, x, animated) {
+      const host = hostRef.current;
+      if (!host) return;
+      if (typeof options === "number") {
+        Commands.scrollTo(host, x ?? 0, options, animated !== false);
+      } else {
+        Commands.scrollTo(host, options?.x ?? 0, options?.y ?? 0, options?.animated !== false);
+      }
+    },
+    scrollToEnd(options) {
+      if (hostRef.current) Commands.scrollToEnd(hostRef.current, options?.animated !== false);
+    },
+    flashScrollIndicators() {
+      if (hostRef.current) Commands.flashScrollIndicators(hostRef.current);
+    },
+    getNativeScrollRef: () => hostRef.current,
+    getScrollableNode: () => findNodeHandle(hostRef.current) ?? null,
+    measure: (...args) => hostRef.current?.measure(...args),
+    measureInWindow: (...args) => hostRef.current?.measureInWindow(...args),
+    measureLayout: (...args) => hostRef.current?.measureLayout(...args),
+    setNativeProps: nativeProps => hostRef.current?.setNativeProps(nativeProps),
+    focus: () => hostRef.current?.focus(),
+    blur: () => hostRef.current?.blur()
+  }), []);
+  const keyboardIsDismissible = () => Boolean(TextInput.State.currentlyFocusedInput() && (Keyboard.isVisible() || Platform.OS === "android" && Number(Platform.Version) < 30) && Keyboard.metrics()?.height !== 0);
+  return /*#__PURE__*/_jsx(NativeScrollerHost, {
     ...props,
-    ref: ref,
-    nativeID: `${NATIVE_SCROLLER_NATIVE_ID_PREFIX}:${scrollKey}`,
-    nestedScrollEnabled: nestedScrollEnabled
+    ref: hostRef,
+    nativeID: `${NATIVE_SCROLLER_NATIVE_ID_PREFIX}:${pagerScrollKey ?? nativeID ?? generatedId}`,
+    style: [styles.viewport, style],
+    nestedScrollEnabled: nestedScrollEnabled,
+    contentWidth: contentSize.width,
+    contentHeight: contentSize.height,
+    contentInsetTop: contentInset?.top ?? 0,
+    contentInsetRight: contentInset?.right ?? 0,
+    contentInsetBottom: contentInset?.bottom ?? 0,
+    contentInsetLeft: contentInset?.left ?? 0,
+    decelerationRate: rate,
+    keyboardShouldPersistTaps: persistTaps,
+    refreshEnabled: Boolean(refresh) && refresh?.enabled !== false,
+    refreshing: refresh?.refreshing ?? false,
+    refreshTintColor: refresh?.tintColor,
+    refreshColors: refresh?.colors,
+    refreshProgressBackgroundColor: refresh?.progressBackgroundColor,
+    refreshProgressViewOffset: refresh?.progressViewOffset ?? 0,
+    refreshTitle: refresh?.title,
+    refreshTitleColor: refresh?.titleColor,
+    refreshSize: refresh?.size === "large" ? "large" : "default",
+    onRefresh: () => {
+      try {
+        refresh?.onRefresh?.();
+      } finally {
+        requestRefreshSync();
+      }
+    },
+    onLayout: onLayout,
+    onContentViewportChange: event => {
+      const height = event.nativeEvent.height;
+      if (!Number.isFinite(height) || height < 0) return;
+      setContentViewportHeight(previous => previous === height ? previous : height);
+    },
+    onScroll: event => {
+      scrolledSinceGrant.current = true;
+      onScroll?.(event);
+    },
+    onScrollBeginDrag: event => {
+      scrolledSinceGrant.current = true;
+      onScrollBeginDrag?.(event);
+    },
+    onMomentumScrollBegin: event => {
+      momentum.current = true;
+      onMomentumScrollBegin?.(event);
+    },
+    onMomentumScrollEnd: event => {
+      momentum.current = false;
+      onMomentumScrollEnd?.(event);
+    },
+    onStartShouldSetResponder: event => onStartShouldSetResponder?.(event) ?? (persistTaps === "handled" && keyboardIsDismissible() && event.target !== TextInput.State.currentlyFocusedInput()),
+    onStartShouldSetResponderCapture: event => onStartShouldSetResponderCapture?.(event) ?? (momentum.current || persistTaps === "never" && keyboardIsDismissible() && typeof event.target !== "number" && !textInputState.isTextInput(event.target)),
+    onResponderGrant: event => {
+      scrolledSinceGrant.current = false;
+      grantedDuringMomentum.current = momentum.current;
+      onResponderGrant?.(event);
+    },
+    onResponderRelease: event => {
+      onResponderRelease?.(event);
+      if (persistTaps !== "always" && keyboardIsDismissible() && event.target !== TextInput.State.currentlyFocusedInput() && !scrolledSinceGrant.current && !grantedDuringMomentum.current) Keyboard.dismiss();
+    },
+    onResponderTerminationRequest: event => onResponderTerminationRequest?.(event) ?? true,
+    children: /*#__PURE__*/_jsx(View, {
+      collapsable: false,
+      style: [contentContainerStyle, (contentStyle?.flexGrow ?? 0) > 0 && (contentStyle?.minHeight === undefined || typeof contentStyle.minHeight === "number") ? {
+        minHeight: Math.max(contentViewportHeight, contentStyle?.minHeight ?? 0)
+      } : undefined, styles.content],
+      onLayout: event => {
+        const {
+          width,
+          height
+        } = event.nativeEvent.layout;
+        const previous = contentSizeRef.current;
+        if (previous.width === width && previous.height === height) return;
+        const next = {
+          width,
+          height
+        };
+        contentSizeRef.current = next;
+        setContentSize(next);
+        onContentSizeChange?.(width, height);
+      },
+      children: children
+    })
   });
 });
 NativeScroller.displayName = "NativeScroller";