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

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

@@ -166,7 +166,7 @@ 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);
+      this.dispatchNativeTabPageCommand(position, this.props.nativeTabPressAnimationEnabled ?? Math.abs(position - this.state.selectedPage) <= 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";

package/lib/module/NativeScrollerNativeComponent.ts

@@ -0,0 +1,101 @@
+import type * as React from "react";
+import {
+  codegenNativeCommands,
+  codegenNativeComponent,
+  type ColorValue,
+  type HostComponent,
+  type ViewProps,
+} from "react-native";
+import type {
+  DirectEventHandler,
+  Double,
+  WithDefault,
+} from "react-native/Libraries/Types/CodegenTypes";
+
+export type NativeScrollerScrollEvent = Readonly<{
+  contentInset: Readonly<{
+    top: Double;
+    right: Double;
+    bottom: Double;
+    left: Double;
+  }>;
+  contentOffset: Readonly<{ x: Double; y: Double }>;
+  contentSize: Readonly<{ width: Double; height: Double }>;
+  layoutMeasurement: Readonly<{ width: Double; height: Double }>;
+  velocity: Readonly<{ x: Double; y: Double }>;
+  targetContentOffset: Readonly<{ x: Double; y: Double }>;
+  zoomScale: Double;
+}>;
+
+export interface NativeProps extends ViewProps {
+  contentWidth?: WithDefault<Double, 0>;
+  contentHeight?: WithDefault<Double, 0>;
+  scrollEnabled?: WithDefault<boolean, true>;
+  nestedScrollEnabled?: WithDefault<boolean, true>;
+  showsVerticalScrollIndicator?: WithDefault<boolean, true>;
+  showsHorizontalScrollIndicator?: WithDefault<boolean, false>;
+  bounces?: WithDefault<boolean, true>;
+  alwaysBounceVertical?: WithDefault<boolean, true>;
+  keyboardDismissMode?: WithDefault<"none" | "on-drag" | "interactive", "none">;
+  keyboardShouldPersistTaps?: WithDefault<
+    "never" | "always" | "handled",
+    "never"
+  >;
+  scrollEventThrottle?: WithDefault<Double, 0>;
+  decelerationRate?: WithDefault<Double, 0.998>;
+  contentInsetTop?: WithDefault<Double, 0>;
+  contentInsetRight?: WithDefault<Double, 0>;
+  contentInsetBottom?: WithDefault<Double, 0>;
+  contentInsetLeft?: WithDefault<Double, 0>;
+  refreshEnabled?: WithDefault<boolean, false>;
+  refreshing?: WithDefault<boolean, false>;
+  refreshTintColor?: ColorValue;
+  refreshColors?: ReadonlyArray<ColorValue>;
+  refreshProgressBackgroundColor?: ColorValue;
+  refreshProgressViewOffset?: WithDefault<Double, 0>;
+  refreshTitle?: string;
+  refreshTitleColor?: ColorValue;
+  refreshSize?: WithDefault<"default" | "large", "default">;
+  onContentViewportChange?: DirectEventHandler<Readonly<{ height: Double }>>;
+  onRefresh?: DirectEventHandler<null>;
+  onScroll?: DirectEventHandler<NativeScrollerScrollEvent>;
+  onScrollBeginDrag?: DirectEventHandler<NativeScrollerScrollEvent>;
+  onScrollEndDrag?: DirectEventHandler<NativeScrollerScrollEvent>;
+  onMomentumScrollBegin?: DirectEventHandler<NativeScrollerScrollEvent>;
+  onMomentumScrollEnd?: DirectEventHandler<NativeScrollerScrollEvent>;
+}
+
+type NativeScrollerHost = HostComponent<NativeProps>;
+
+export interface NativeCommands {
+  scrollTo: (
+    viewRef: React.ElementRef<NativeScrollerHost>,
+    x: Double,
+    y: Double,
+    animated: boolean
+  ) => void;
+  scrollToEnd: (
+    viewRef: React.ElementRef<NativeScrollerHost>,
+    animated: boolean
+  ) => void;
+  flashScrollIndicators: (
+    viewRef: React.ElementRef<NativeScrollerHost>
+  ) => void;
+  setRefreshState: (
+    viewRef: React.ElementRef<NativeScrollerHost>,
+    refreshing: boolean
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: [
+    "scrollTo",
+    "scrollToEnd",
+    "flashScrollIndicators",
+    "setRefreshState",
+  ],
+});
+
+export default codegenNativeComponent<NativeProps>("RNCNativeScroller", {
+  interfaceOnly: true,
+}) as NativeScrollerHost;

package/lib/typescript/src/CollapsiblePagerView.d.ts

@@ -80,9 +80,8 @@ export interface CollapsiblePagerViewProps extends Omit<NativeProps, "children"
     nativeTabBar?: CollapsiblePagerNativeTabBarConfig;
     onNativeTabPress?: (event: CollapsiblePagerViewOnNativeTabPressEvent) => void;
     /**
-     * Animates the page change started by a native tab press. Defaults to true.
-     * Set false to jump straight to the pressed page, so a distant tab does not
-     * scroll through every page in between, including unmounted ones.
+     * Defaults to animating adjacent native tab presses and jumping directly to
+     * non-adjacent pages. Set true to always animate, or false to always jump.
      */
     nativeTabPressAnimationEnabled?: boolean;
     /** Optional native secondary sticky header for iOS and Android. */

package/lib/typescript/src/NativeScroller.d.ts

@@ -1,12 +1,20 @@
 import * as React from "react";
-import { type ScrollViewProps } from "react-native";
+import { type NativeMethods, type RefreshControlProps, type ScrollView, type ScrollViewProps, type ViewProps } from "react-native";
+import NativeScrollerHost from "./NativeScrollerNativeComponent";
 export declare const NATIVE_SCROLLER_NATIVE_ID_PREFIX = "rnc-collapsible-pager-native-scroller";
-export interface NativeScrollerProps extends ScrollViewProps {
-    /** Stable identity used when a page replaces or remounts its primary scroller. */
+/** Supported vertical subset; horizontal, snapping, zoom and sticky rows are not supported. */
+export interface NativeScrollerProps extends ViewProps, Pick<ScrollViewProps, "contentContainerStyle" | "onContentSizeChange" | "scrollEnabled" | "nestedScrollEnabled" | "showsVerticalScrollIndicator" | "showsHorizontalScrollIndicator" | "bounces" | "alwaysBounceVertical" | "contentInset" | "keyboardDismissMode" | "keyboardShouldPersistTaps" | "scrollEventThrottle" | "decelerationRate" | "onScroll" | "onScrollBeginDrag" | "onScrollEndDrag" | "onMomentumScrollBegin" | "onMomentumScrollEnd"> {
     pagerScrollKey?: string;
+    /** iOS only. Android retains AndroidX's native fling physics. */
+    decelerationRate?: ScrollViewProps["decelerationRate"];
+    /** Standard RefreshControl props are mapped to the independently owned native controller. */
+    refreshControl?: React.ReactElement<RefreshControlProps>;
 }
-/**
- * Primary non-virtualized vertical scroller for a CollapsiblePagerView page.
- */
-export declare const NativeScroller: React.ForwardRefExoticComponent<NativeScrollerProps & React.RefAttributes<import("react-native/types_generated/Libraries/Components/ScrollView/ScrollView").PublicScrollViewInstance>>;
+type HostRef = React.ElementRef<typeof NativeScrollerHost>;
+export interface NativeScrollerRef extends NativeMethods, Pick<React.ElementRef<typeof ScrollView>, "scrollTo" | "scrollToEnd" | "flashScrollIndicators"> {
+    getNativeScrollRef(): HostRef | null;
+    getScrollableNode(): number | null;
+}
+export declare const NativeScroller: React.ForwardRefExoticComponent<NativeScrollerProps & React.RefAttributes<NativeScrollerRef>>;
+export {};
 //# sourceMappingURL=NativeScroller.d.ts.map