@onekeyfe/react-native-pager-view 6.7.0-alpha.430 → 6.7.0-alpha.435

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

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

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

@@ -65,6 +65,6 @@ export declare class PagerView extends React.Component<NativeProps> {
      * imperative solution is more useful (e.g. for not blocking an animation)
      */
     setScrollEnabled: (scrollEnabled: boolean) => void;
-    render(): import("react/jsx-runtime").JSX.Element;
+    render(): React.JSX.Element;
 }
 //# sourceMappingURL=PagerView.d.ts.map

package/lib/typescript/src/PagerView.web.d.ts

@@ -47,7 +47,7 @@ export declare class PagerView extends React.Component<PagerViewProps, State> {
     private selectPage;
     private onTouchStart;
     private onTouchEnd;
-    render(): import("react/jsx-runtime").JSX.Element;
+    render(): React.JSX.Element;
 }
 export type PagerViewOnPageScrollEvent = ReactNative.NativeSyntheticEvent<PagerViewOnPageScrollEventData>;
 export type PagerViewOnPageSelectedEvent = ReactNative.NativeSyntheticEvent<PagerViewOnPageSelectedEventData>;

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

@@ -1,48 +1,47 @@
 import type * as React from 'react';
-import { type HostComponent, type ViewProps } from 'react-native';
-import type { DirectEventHandler, Double, Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+import { type CodegenTypes, type HostComponent, type ViewProps } from 'react-native';
 export type OnPageScrollEventData = Readonly<{
-    position: Double;
-    offset: Double;
+    position: CodegenTypes.Double;
+    offset: CodegenTypes.Double;
 }>;
 export type OnPageSelectedEventData = Readonly<{
-    position: Double;
+    position: CodegenTypes.Double;
 }>;
 export type OnPageScrollStateChangedEventData = Readonly<{
     pageScrollState: 'idle' | 'dragging' | 'settling';
 }>;
 export interface NativeProps extends ViewProps {
-    scrollEnabled?: WithDefault<boolean, true>;
-    layoutDirection?: WithDefault<'ltr' | 'rtl', 'ltr'>;
-    initialPage?: Int32;
-    orientation?: WithDefault<'horizontal' | 'vertical', 'horizontal'>;
-    offscreenPageLimit?: Int32;
-    pageMargin?: Int32;
-    overScrollMode?: WithDefault<'auto' | 'always' | 'never', 'auto'>;
-    overdrag?: WithDefault<boolean, false>;
-    keyboardDismissMode?: WithDefault<'none' | 'on-drag', 'none'>;
+    scrollEnabled?: CodegenTypes.WithDefault<boolean, true>;
+    layoutDirection?: CodegenTypes.WithDefault<'ltr' | 'rtl', 'ltr'>;
+    initialPage?: CodegenTypes.Int32;
+    orientation?: CodegenTypes.WithDefault<'horizontal' | 'vertical', 'horizontal'>;
+    offscreenPageLimit?: CodegenTypes.Int32;
+    pageMargin?: CodegenTypes.Int32;
+    overScrollMode?: CodegenTypes.WithDefault<'auto' | 'always' | 'never', 'auto'>;
+    overdrag?: CodegenTypes.WithDefault<boolean, false>;
+    keyboardDismissMode?: CodegenTypes.WithDefault<'none' | 'on-drag', 'none'>;
     /**
     * Controls the sensitivity of scroll gestures on Android.
     * Higher values make scrolling less sensitive.
     * Valid range: 2 - 8
     * @platform android
     */
-    scrollSensitivity?: Int32;
+    scrollSensitivity?: CodegenTypes.Int32;
     /**
     * When true on an inner PagerView, enables gesture coordination with
     * a parent (outer) PagerView. At sub-tab boundaries the inner pager's
     * gesture recognizer will not begin, allowing the outer pager to take over.
     * @platform ios
     */
-    nestedScrollEnabled?: WithDefault<boolean, false>;
-    onPageScroll?: DirectEventHandler<OnPageScrollEventData>;
-    onPageSelected?: DirectEventHandler<OnPageSelectedEventData>;
-    onPageScrollStateChanged?: DirectEventHandler<OnPageScrollStateChangedEventData>;
+    nestedScrollEnabled?: CodegenTypes.WithDefault<boolean, false>;
+    onPageScroll?: CodegenTypes.DirectEventHandler<OnPageScrollEventData>;
+    onPageSelected?: CodegenTypes.DirectEventHandler<OnPageSelectedEventData>;
+    onPageScrollStateChanged?: CodegenTypes.DirectEventHandler<OnPageScrollStateChangedEventData>;
 }
 type PagerViewViewType = HostComponent<NativeProps>;
 export interface NativeCommands {
-    setPage: (viewRef: React.ElementRef<PagerViewViewType>, selectedPage: Int32) => void;
-    setPageWithoutAnimation: (viewRef: React.ElementRef<PagerViewViewType>, selectedPage: Int32) => void;
+    setPage: (viewRef: React.ElementRef<PagerViewViewType>, selectedPage: CodegenTypes.Int32) => void;
+    setPageWithoutAnimation: (viewRef: React.ElementRef<PagerViewViewType>, selectedPage: CodegenTypes.Int32) => void;
     setScrollEnabledImperatively: (viewRef: React.ElementRef<PagerViewViewType>, scrollEnabled: boolean) => void;
 }
 export declare const Commands: NativeCommands;

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

@@ -38,5 +38,5 @@ export declare function WebCollapsiblePagerPage({ children, pageKey, isFocused,
     onGeometryChange: (key: string) => void;
     onScroll: (key: string, top: number) => void;
     onUserInput: (key: string) => void;
-}>): import("react/jsx-runtime").JSX.Element;
+}>): React.JSX.Element;
 //# sourceMappingURL=WebCollapsiblePagerPage.d.ts.map

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

@@ -27,8 +27,8 @@ export declare function usePagerView({ pagesAmount }?: UsePagerViewParams): {
         position: number;
         offset: number;
     }>>;
-    onPageScroll: any;
-    onPageSelected: any;
+    onPageScroll: (...args: Array<any>) => void;
+    onPageSelected: (...args: Array<any>) => void;
     onPageScrollStateChanged: (e: PageScrollStateChangedNativeEvent) => void;
     toggleOverdrag: () => void;
     AnimatedPagerView: ReactNative.Animated.AnimatedComponent<Readonly<import("./PagerViewNativeComponent").NativeProps>, PagerView>;

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

@@ -1,3 +1,3 @@
-import { ReactNode } from 'react';
-export declare const childrenWithOverriddenStyle: (children?: ReactNode) => import("react/jsx-runtime").JSX.Element[] | null | undefined;
+import React, { ReactNode } from 'react';
+export declare const childrenWithOverriddenStyle: (children?: ReactNode) => React.JSX.Element[] | null | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-pager-view",
-  "version": "6.7.0-alpha.430",
+  "version": "6.7.0-alpha.435",
   "description": "React Native wrapper for Android and iOS ViewPager",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",
@@ -67,14 +67,14 @@
     "access": "public"
   },
   "devDependencies": {
-    "@types/react": "^19.2.0",
-    "react": "19.2.3",
-    "react-native": "patch:react-native@npm%3A0.86.2#~/.yarn/patches/react-native-npm-0.86.2-c9d546616f.patch",
+    "@types/react": "^19.3.0",
+    "react": "19.3.0",
+    "react-native": "patch:react-native@npm%3A0.88.0#~/.yarn/patches/react-native-npm-0.88.0-60c6201dd2.patch",
     "react-native-builder-bob": "^0.40.13",
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@onekeyfe/react-native-native-logger": "6.7.0-alpha.430",
+    "@onekeyfe/react-native-native-logger": "6.7.0-alpha.435",
     "react": "*",
     "react-native": "*"
   },

package/src/CollapsiblePagerViewNativeComponent.ts

@@ -2,25 +2,20 @@ import type * as React from "react";
 import {
   codegenNativeCommands,
   codegenNativeComponent,
+  type CodegenTypes,
   type ColorValue,
   type HostComponent,
   type ViewProps,
 } from "react-native";
 
-import type {
-  DirectEventHandler,
-  Double,
-  Int32,
-  WithDefault,
-} from "react-native/Libraries/Types/CodegenTypes";
 
 export type OnPageScrollEventData = Readonly<{
-  position: Double;
-  offset: Double;
+  position: CodegenTypes.Double;
+  offset: CodegenTypes.Double;
 }>;
 
 export type OnPageSelectedEventData = Readonly<{
-  position: Double;
+  position: CodegenTypes.Double;
 }>;
 
 export type OnPageScrollStateChangedEventData = Readonly<{
@@ -28,11 +23,11 @@ export type OnPageScrollStateChangedEventData = Readonly<{
 }>;
 
 export type OnCollapsibleStateChangedEventData = Readonly<{
-  position: Int32;
-  headerOffset: Double;
-  nativePageCount: Int32;
-  attachedPageCount: Int32;
-  observedScrollableCount: Int32;
+  position: CodegenTypes.Int32;
+  headerOffset: CodegenTypes.Double;
+  nativePageCount: CodegenTypes.Int32;
+  attachedPageCount: CodegenTypes.Int32;
+  observedScrollableCount: CodegenTypes.Int32;
   retainedPages: string;
   reason: string;
   pageKey: string;
@@ -40,7 +35,7 @@ export type OnCollapsibleStateChangedEventData = Readonly<{
 }>;
 
 export type OnNativeTabPressEventData = Readonly<{
-  position: Int32;
+  position: CodegenTypes.Int32;
   key: string;
 }>;
 export type OnScrollEdgeCapabilityEventData = Readonly<{ available: boolean }>;
@@ -50,45 +45,45 @@ export type OnScrollEdgeCapabilityEventData = Readonly<{ available: boolean }>;
  * CollapsiblePagerView instead of mounting this host component directly.
  */
 export interface NativeProps extends ViewProps {
-  scrollEnabled?: WithDefault<boolean, true>;
-  layoutDirection?: WithDefault<"ltr" | "rtl", "ltr">;
-  initialPage?: Int32;
-  offscreenPageLimit?: Int32;
+  scrollEnabled?: CodegenTypes.WithDefault<boolean, true>;
+  layoutDirection?: CodegenTypes.WithDefault<"ltr" | "rtl", "ltr">;
+  initialPage?: CodegenTypes.Int32;
+  offscreenPageLimit?: CodegenTypes.Int32;
   // OneKey patch: Preserve nested pager gesture coordination for collapsible pages.
-  nestedScrollEnabled?: WithDefault<boolean, false>;
-  nativeSmoothHeaderScrollEnabled?: WithDefault<boolean, false>;
-  headerHeight?: Int32;
-  stickyHeaderHeight?: Int32;
-  topScrollEdgeEffect?: WithDefault<"none" | "hard" | "soft", "none">;
+  nestedScrollEnabled?: CodegenTypes.WithDefault<boolean, false>;
+  nativeSmoothHeaderScrollEnabled?: CodegenTypes.WithDefault<boolean, false>;
+  headerHeight?: CodegenTypes.Int32;
+  stickyHeaderHeight?: CodegenTypes.Int32;
+  topScrollEdgeEffect?: CodegenTypes.WithDefault<"none" | "hard" | "soft", "none">;
   topOverlayColorScheme?: string;
-  topOverlayHeight?: WithDefault<Double, 0>;
-  externalTopOverlayTag?: WithDefault<Int32, 0>;
+  topOverlayHeight?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  externalTopOverlayTag?: CodegenTypes.WithDefault<CodegenTypes.Int32, 0>;
   pageKeys?: string;
   retainedPages?: string;
   nativeTabBarItems?: string;
-  nativeTabBarHeight?: Double;
+  nativeTabBarHeight?: CodegenTypes.Double;
   nativeTabBarVariant?: string;
-  nativeTabBarTrailingReservedWidth?: WithDefault<Double, 0>;
-  nativeTabBarContentPaddingHorizontal?: Double;
-  nativeTabBarContentPaddingVertical?: Double;
-  nativeTabBarItemSpacing?: Double;
-  nativeTabBarFontSize?: Double;
+  nativeTabBarTrailingReservedWidth?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  nativeTabBarContentPaddingHorizontal?: CodegenTypes.Double;
+  nativeTabBarContentPaddingVertical?: CodegenTypes.Double;
+  nativeTabBarItemSpacing?: CodegenTypes.Double;
+  nativeTabBarFontSize?: CodegenTypes.Double;
   nativeTabBarFontFamily?: string;
   nativeTabBarBackgroundColor?: ColorValue;
   nativeTabBarActiveTextColor?: ColorValue;
   nativeTabBarInactiveTextColor?: ColorValue;
   nativeTabBarIndicatorColor?: ColorValue;
-  nativeTabBarIndicatorHeight?: Double;
-  nativeTabBarIndicatorBottom?: Double;
+  nativeTabBarIndicatorHeight?: CodegenTypes.Double;
+  nativeTabBarIndicatorBottom?: CodegenTypes.Double;
   nativeSubHeaderConfig?: string;
   nativeSubHeaderSelectedBackgroundColor?: ColorValue;
-  onPageScroll?: DirectEventHandler<OnPageScrollEventData>;
-  onPageSelected?: DirectEventHandler<OnPageSelectedEventData>;
-  onPageScrollStateChanged?: DirectEventHandler<OnPageScrollStateChangedEventData>;
-  onCollapsibleStateChanged?: DirectEventHandler<OnCollapsibleStateChangedEventData>;
-  onNativeTabPress?: DirectEventHandler<OnNativeTabPressEventData>;
-  onNativeSubHeaderPress?: DirectEventHandler<OnNativeTabPressEventData>;
-  onScrollEdgeCapability?: DirectEventHandler<OnScrollEdgeCapabilityEventData>;
+  onPageScroll?: CodegenTypes.DirectEventHandler<OnPageScrollEventData>;
+  onPageSelected?: CodegenTypes.DirectEventHandler<OnPageSelectedEventData>;
+  onPageScrollStateChanged?: CodegenTypes.DirectEventHandler<OnPageScrollStateChangedEventData>;
+  onCollapsibleStateChanged?: CodegenTypes.DirectEventHandler<OnCollapsibleStateChangedEventData>;
+  onNativeTabPress?: CodegenTypes.DirectEventHandler<OnNativeTabPressEventData>;
+  onNativeSubHeaderPress?: CodegenTypes.DirectEventHandler<OnNativeTabPressEventData>;
+  onScrollEdgeCapability?: CodegenTypes.DirectEventHandler<OnScrollEdgeCapabilityEventData>;
 }
 
 type CollapsiblePagerViewNativeType = HostComponent<NativeProps>;
@@ -96,24 +91,24 @@ type CollapsiblePagerViewNativeType = HostComponent<NativeProps>;
 export interface NativeCommands {
   scrollHeaderToOffset: (
     viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
-    offset: Double
+    offset: CodegenTypes.Double
   ) => void;
   scrollHeaderBy: (
     viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
-    delta: Double
+    delta: CodegenTypes.Double
   ) => void;
   scrollToTop: (
     viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
-    target: Int32,
+    target: CodegenTypes.Int32,
     animated: boolean
   ) => void;
   setPage: (
     viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
-    selectedPage: Int32
+    selectedPage: CodegenTypes.Int32
   ) => void;
   setPageWithoutAnimation: (
     viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,
-    selectedPage: Int32
+    selectedPage: CodegenTypes.Int32
   ) => void;
   setScrollEnabledImperatively: (
     viewRef: React.ElementRef<CollapsiblePagerViewNativeType>,

package/src/NativeScroller.tsx

@@ -7,7 +7,7 @@ import {
   TextInput,
   View,
   type GestureResponderEvent,
-  type NativeMethods,
+  type HostInstance,
   type RefreshControlProps,
   type ScrollView,
   type ScrollViewProps,
@@ -35,7 +35,6 @@ export interface NativeScrollerProps
       | "alwaysBounceVertical"
       | "contentInset"
       | "keyboardDismissMode"
-      | "keyboardShouldPersistTaps"
       | "scrollEventThrottle"
       | "decelerationRate"
       | "onScroll"
@@ -53,12 +52,24 @@ export interface NativeScrollerProps
   decelerationRate?: ScrollViewProps["decelerationRate"];
   /** Standard RefreshControl props are mapped to the independently owned native controller. */
   refreshControl?: React.ReactElement<RefreshControlProps>;
+  /** Boolean values are deprecated compatibility aliases (`true` -> `always`, `false` -> `never`). */
+  keyboardShouldPersistTaps?:
+    | ScrollViewProps["keyboardShouldPersistTaps"]
+    | boolean;
 }
 
 type HostRef = React.ElementRef<typeof NativeScrollerHost>;
 
 export interface NativeScrollerRef
-  extends NativeMethods,
+  extends Pick<
+      HostInstance,
+      | "measure"
+      | "measureInWindow"
+      | "measureLayout"
+      | "setNativeProps"
+      | "focus"
+      | "blur"
+    >,
     Pick<
       React.ElementRef<typeof ScrollView>,
       "scrollTo" | "scrollToEnd" | "flashScrollIndicators"

package/src/NativeScroller.web.tsx

@@ -16,8 +16,15 @@ export const NativeScroller = React.forwardRef<
     pagerScrollKey,
     topOverlay: _topOverlay,
     topScrollEdgeEffect: _topScrollEdgeEffect,
+    keyboardShouldPersistTaps,
     ...props
   } = inputProps as NativeScrollerWebProps;
+  const persistTaps =
+    keyboardShouldPersistTaps === true
+      ? "always"
+      : keyboardShouldPersistTaps === false
+      ? "never"
+      : keyboardShouldPersistTaps;
   const scrollRef = React.useRef<React.ElementRef<typeof ScrollView>>(null);
   const setRef = React.useCallback(
     (node: React.ElementRef<typeof ScrollView> | null) => {
@@ -47,7 +54,14 @@ export const NativeScroller = React.forwardRef<
     },
   };
 
-  return <ScrollView {...props} ref={setRef} {...webDataProps} />;
+  return (
+    <ScrollView
+      {...props}
+      keyboardShouldPersistTaps={persistTaps}
+      ref={setRef}
+      {...webDataProps}
+    />
+  );
 });
 
 NativeScroller.displayName = "NativeScroller";

package/src/NativeScrollerNativeComponent.ts

@@ -2,69 +2,66 @@ import type * as React from "react";
 import {
   codegenNativeCommands,
   codegenNativeComponent,
+  type CodegenTypes,
   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;
+    top: CodegenTypes.Double;
+    right: CodegenTypes.Double;
+    bottom: CodegenTypes.Double;
+    left: CodegenTypes.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;
+  contentOffset: Readonly<{ x: CodegenTypes.Double; y: CodegenTypes.Double }>;
+  contentSize: Readonly<{ width: CodegenTypes.Double; height: CodegenTypes.Double }>;
+  layoutMeasurement: Readonly<{ width: CodegenTypes.Double; height: CodegenTypes.Double }>;
+  velocity: Readonly<{ x: CodegenTypes.Double; y: CodegenTypes.Double }>;
+  targetContentOffset: Readonly<{ x: CodegenTypes.Double; y: CodegenTypes.Double }>;
+  zoomScale: CodegenTypes.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<
+  contentWidth?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  contentHeight?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  scrollEnabled?: CodegenTypes.WithDefault<boolean, true>;
+  nestedScrollEnabled?: CodegenTypes.WithDefault<boolean, true>;
+  showsVerticalScrollIndicator?: CodegenTypes.WithDefault<boolean, true>;
+  showsHorizontalScrollIndicator?: CodegenTypes.WithDefault<boolean, false>;
+  bounces?: CodegenTypes.WithDefault<boolean, true>;
+  alwaysBounceVertical?: CodegenTypes.WithDefault<boolean, true>;
+  keyboardDismissMode?: CodegenTypes.WithDefault<"none" | "on-drag" | "interactive", "none">;
+  keyboardShouldPersistTaps?: CodegenTypes.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>;
-  topScrollEdgeEffect?: WithDefault<"none" | "hard" | "soft", "none">;
-  topOverlayHeight?: WithDefault<Double, 0>;
-  refreshEnabled?: WithDefault<boolean, false>;
-  refreshing?: WithDefault<boolean, false>;
+  scrollEventThrottle?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  decelerationRate?: CodegenTypes.WithDefault<CodegenTypes.Double, 0.998>;
+  contentInsetTop?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  contentInsetRight?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  contentInsetBottom?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  contentInsetLeft?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  topScrollEdgeEffect?: CodegenTypes.WithDefault<"none" | "hard" | "soft", "none">;
+  topOverlayHeight?: CodegenTypes.WithDefault<CodegenTypes.Double, 0>;
+  refreshEnabled?: CodegenTypes.WithDefault<boolean, false>;
+  refreshing?: CodegenTypes.WithDefault<boolean, false>;
   refreshTintColor?: ColorValue;
   refreshColors?: ReadonlyArray<ColorValue>;
   refreshProgressBackgroundColor?: ColorValue;
-  refreshProgressViewOffset?: WithDefault<Double, 0>;
+  refreshProgressViewOffset?: CodegenTypes.WithDefault<CodegenTypes.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>;
+  refreshSize?: CodegenTypes.WithDefault<"default" | "large", "default">;
+  onContentViewportChange?: CodegenTypes.DirectEventHandler<Readonly<{ height: CodegenTypes.Double }>>;
+  onRefresh?: CodegenTypes.DirectEventHandler<null>;
+  onScroll?: CodegenTypes.DirectEventHandler<NativeScrollerScrollEvent>;
+  onScrollBeginDrag?: CodegenTypes.DirectEventHandler<NativeScrollerScrollEvent>;
+  onScrollEndDrag?: CodegenTypes.DirectEventHandler<NativeScrollerScrollEvent>;
+  onMomentumScrollBegin?: CodegenTypes.DirectEventHandler<NativeScrollerScrollEvent>;
+  onMomentumScrollEnd?: CodegenTypes.DirectEventHandler<NativeScrollerScrollEvent>;
 }
 
 type NativeScrollerHost = HostComponent<NativeProps>;
@@ -72,8 +69,8 @@ type NativeScrollerHost = HostComponent<NativeProps>;
 export interface NativeCommands {
   scrollTo: (
     viewRef: React.ElementRef<NativeScrollerHost>,
-    x: Double,
-    y: Double,
+    x: CodegenTypes.Double,
+    y: CodegenTypes.Double,
     animated: boolean
   ) => void;
   scrollToEnd: (