first commit

components/z-paging/js/modules/back-to-top.js

@@ -0,0 +1,108 @@
+// [z-paging]点击返回顶部view模块
+import u from '.././z-paging-utils'
+
+const ZPBackToTop = {
+	props: {
+		//自动显示点击返回顶部按钮，默认为否
+		autoShowBackToTop: {
+			type: Boolean,
+			default: u.gc('autoShowBackToTop', false)
+		},
+		//点击返回顶部按钮显示/隐藏的阈值(滚动距离)，单位为px，默认为400rpx
+		backToTopThreshold: {
+			type: [Number, String],
+			default: u.gc('backToTopThreshold', '400rpx')
+		},
+		//点击返回顶部按钮的自定义图片地址，默认使用z-paging内置的图片
+		backToTopImg: {
+			type: String,
+			default: u.gc('backToTopImg', '')
+		},
+		//点击返回顶部按钮返回到顶部时是否展示过渡动画，默认为是
+		backToTopWithAnimate: {
+			type: Boolean,
+			default: u.gc('backToTopWithAnimate', true)
+		},
+		//点击返回顶部按钮与底部的距离，注意添加单位px或rpx，默认为160rpx
+		backToTopBottom: {
+			type: [Number, String],
+			default: u.gc('backToTopBottom', '160rpx')
+		},
+		//点击返回顶部按钮的自定义样式
+		backToTopStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('backToTopStyle', {});
+			},
+		},
+		//iOS点击顶部状态栏、安卓双击标题栏时，滚动条返回顶部，只支持竖向，默认为是
+		enableBackToTop: {
+			type: Boolean,
+			default: u.gc('enableBackToTop', true)
+		},
+	},
+	data() {
+		return {
+			backToTopClass: 'zp-back-to-top zp-back-to-top-hide',
+			lastBackToTopShowTime: 0,
+			showBackToTopClass: false,
+		}
+	},
+	computed: {
+		finalEnableBackToTop() {
+			return this.usePageScroll ? false : this.enableBackToTop;
+		},
+		finalBackToTopThreshold() {
+			return u.convertTextToPx(this.backToTopThreshold);
+		},
+		finalBackToTopStyle() {
+			let tempBackToTopStyle = this.backToTopStyle;
+			if (!tempBackToTopStyle.bottom) {
+				tempBackToTopStyle.bottom = this.windowBottom + u.convertTextToPx(this.backToTopBottom) + 'px';
+			}
+			if(!tempBackToTopStyle.position){
+				tempBackToTopStyle.position = this.usePageScroll ? 'fixed': 'absolute';
+			}
+			return tempBackToTopStyle;
+		},
+	},
+	methods: {
+		//点击返回顶部
+		_backToTopClick() {
+			!this.backToTopWithAnimate && this._checkShouldShowBackToTop(1, 0);
+			this.scrollToTop(this.backToTopWithAnimate);
+		},
+		//判断是否要显示返回顶部按钮
+		_checkShouldShowBackToTop(newVal, oldVal) {
+			if (!this.autoShowBackToTop) {
+				this.showBackToTopClass = false;
+				return;
+			}
+			if (newVal !== oldVal) {
+				if (newVal > this.finalBackToTopThreshold) {
+					if (!this.showBackToTopClass) {
+						this.showBackToTopClass = true;
+						this.lastBackToTopShowTime = new Date().getTime();
+						setTimeout(() => {
+							this.backToTopClass = 'zp-back-to-top zp-back-to-top-show';
+						}, 300)
+					}
+				} else {
+					if (this.showBackToTopClass) {
+						const currentTime = new Date().getTime();
+						let dalayTime = 300;
+						if(currentTime - this.lastBackToTopShowTime < 500){
+							dalayTime = 0;
+						}
+						this.backToTopClass = 'zp-back-to-top zp-back-to-top-hide';
+						setTimeout(() => {
+							this.showBackToTopClass = false;
+						}, dalayTime)
+					}
+				}
+			}
+		},
+	}
+}
+
+export default ZPBackToTop;

components/z-paging/js/modules/data-handle.js

@@ -0,0 +1,732 @@
+// [z-paging]数据处理模块
+import u from '.././z-paging-utils'
+import c from '.././z-paging-constant'
+import Enum from '.././z-paging-enum'
+import interceptor from '../z-paging-interceptor'
+
+const ZPData = {
+	props: {
+		//自定义初始的pageNo，默认为1
+		defaultPageNo: {
+			type: [Number, String],
+			default: u.gc('defaultPageNo', 1),
+			observer: function(newVal, oldVal) {
+				this.pageNo = newVal;
+			},
+		},
+		//自定义pageSize，默认为10
+		defaultPageSize: {
+			type: [Number, String],
+			default: u.gc('defaultPageSize', 10),
+			validator: (value) => {
+				if(value <= 0) u.consoleErr('default-page-size必须大于0！');
+				return value > 0;
+			}
+		},
+		//为保证数据一致，设置当前tab切换时的标识key，并在complete中传递相同key，若二者不一致，则complete将不会生效
+		dataKey: {
+			type: [Number, String, Object],
+			default: function() {
+				return u.gc('dataKey', null);
+			},
+		},
+		//自动注入的list名，可自动修改父view(包含ref="paging")中对应name的list值
+		autowireListName: {
+			type: String,
+			default: function() {
+				return u.gc('autowireListName', '');
+			},
+		},
+		//自动注入的query名，可自动调用父view(包含ref="paging")中的query方法
+		autowireQueryName: {
+			type: String,
+			default: function() {
+				return u.gc('autowireQueryName', '');
+			},
+		},
+		//z-paging mounted后自动调用reload方法(mounted后自动调用接口)，默认为是。请使用简便写法：auto
+		mountedAutoCallReload: {
+			type: Boolean,
+			default: u.gc('mountedAutoCallReload', true)
+		},
+		//z-paging mounted后自动调用reload方法(mounted后自动调用接口)，默认为是
+		auto: {
+			type: Boolean,
+			default: u.gc('auto', true)
+		},
+		//用户下拉刷新时是否触发reload方法，默认为是
+		reloadWhenRefresh: {
+			type: Boolean,
+			default: u.gc('reloadWhenRefresh', true)
+		},
+		//reload时自动滚动到顶部，默认为是
+		autoScrollToTopWhenReload: {
+			type: Boolean,
+			default: u.gc('autoScrollToTopWhenReload', true)
+		},
+		//reload时立即自动清空原list，默认为是，若立即自动清空，则在reload之后、请求回调之前页面是空白的
+		autoCleanListWhenReload: {
+			type: Boolean,
+			default: u.gc('autoCleanListWhenReload', true)
+		},
+		//列表刷新时自动显示下拉刷新view，默认为否
+		showRefresherWhenReload: {
+			type: Boolean,
+			default: u.gc('showRefresherWhenReload', false)
+		},
+		//列表刷新时自动显示加载更多view，且为加载中状态，默认为否
+		showLoadingMoreWhenReload: {
+			type: Boolean,
+			default: u.gc('showLoadingMoreWhenReload', false)
+		},
+		//组件created时立即触发reload(可解决一些情况下先看到页面再看到loading的问题)，auto为true时有效。为否时将在mounted+nextTick后触发reload，默认为否
+		createdReload: {
+			type: Boolean,
+			default: u.gc('createdReload', false)
+		},
+		//本地分页时上拉加载更多延迟时间，单位为毫秒，默认200毫秒
+		localPagingLoadingTime: {
+			type: [Number, String],
+			default: u.gc('localPagingLoadingTime', 200)
+		},
+		//当分页未满一屏时，是否自动加载更多，默认为否(nvue无效)
+		insideMore: {
+			type: Boolean,
+			default: u.gc('insideMore', false)
+		},
+		//使用聊天记录模式，默认为否
+		useChatRecordMode: {
+			type: Boolean,
+			default: u.gc('useChatRecordMode', false)
+		},
+		//自动拼接complete中传过来的数组(使用聊天记录模式时无效)
+		concat: {
+			type: Boolean,
+			default: u.gc('concat', true)
+		},
+		//父组件v-model所绑定的list的值
+		value: {
+			type: Array,
+			default: function() {
+				return [];
+			}
+		},
+		// #ifdef VUE3
+		modelValue: {
+			type: Array,
+			default: function() {
+				return [];
+			}
+		}
+		// #endif
+	},
+	data (){
+		return {
+			currentData: [],
+			totalData: [],
+			realTotalData: [],
+			totalLocalPagingList: [],
+			pageNo: 1,
+			isLocalPaging: false,
+			isAddedData: false,
+			isTotalChangeFromAddData: false,
+			privateConcat: true,
+			myParentQuery: -1,
+			firstPageLoaded: false,
+			pagingLoaded: false,
+			loaded: false,
+			isUserReload: true,
+			fromEmptyViewReload: false,
+			listRendering: false
+		}
+	},
+	computed: {
+		pageSize() {
+			return this.defaultPageSize;
+		},
+		finalConcat() {
+			return this.concat && this.privateConcat;
+		},
+		isFirstPage() {
+			return this.pageNo === this.defaultPageNo;
+		}
+	},
+	watch: {
+		totalData(newVal, oldVal) {
+			this._totalDataChange(newVal, oldVal);
+		},
+		currentData(newVal, oldVal) {
+			this._currentDataChange(newVal, oldVal);
+		},
+		useChatRecordMode(newVal, oldVal) {
+			if (newVal) {
+				this.nLoadingMoreFixedHeight = false;
+			}
+		},
+		value: {
+			handler(newVal) {
+				this.realTotalData = newVal;
+			},
+			immediate: true
+		},
+		// #ifdef VUE3
+		modelValue: {
+			handler(newVal) {
+				this.realTotalData = newVal;
+			},
+			immediate: true
+		}
+		// #endif
+	},
+	methods: {
+		//请求结束(成功或者失败)调用此方法，将请求的结果传递给z-paging处理，第一个参数为请求结果数组，第二个参数为是否成功(默认是是）
+		complete(data, success = true) {
+			this.customNoMore = -1;
+			this.addData(data, success);
+		},
+		//简写，与complete完全相同
+		end(data, success = true) {
+			this.complete(data, success);
+		},
+		//【保证数据一致】请求结束(成功或者失败)调用此方法，将请求的结果传递给z-paging处理，第一个参数为请求结果数组，第二个参数为dataKey，需与:data-key绑定的一致，第三个参数为是否成功(默认为是）
+		completeByKey(data, dataKey = null, success = true) {
+			if (dataKey !== null && this.dataKey !== null && dataKey !== this.dataKey) {
+				if (this.isFirstPage) {
+					this.endRefresh();
+				}
+				return;
+			}
+			this.customNoMore = -1;
+			this.addData(data, success);
+		},
+		//简写，与completeByKey完全相同
+		endByKey(data, dataKey = null, success = true) {
+			this.completeByKey(data, dataKey, success);
+		},
+		//【通过totalCount判断是否有更多数据】请求结束(成功或者失败)调用此方法，将请求的结果传递给z-paging处理，第一个参数为请求结果数组，第二个参数为totalCount(列表总数)，第三个参数为是否成功(默认为是）
+		completeByTotalCount(data, totalCount, success = true) {
+			if (totalCount == 'undefined') {
+				this.customNoMore = -1;
+			} else {
+				let dataTypeRes = this._checkDataType(data, success, false);
+				data = dataTypeRes.data;
+				success = dataTypeRes.success;
+				if (totalCount >= 0 && success) {
+					this.$nextTick(() => {
+						let nomore = true;
+						let realTotalDataCount = this.realTotalData.length;
+						if (this.pageNo == this.defaultPageNo) {
+							realTotalDataCount = 0;
+						}
+						let exceedCount = realTotalDataCount + data.length - totalCount;
+						if (exceedCount >= 0) {
+							nomore = false;
+							exceedCount = this.defaultPageSize - exceedCount;
+							if (exceedCount > 0 && exceedCount < data.length) {
+								data = data.splice(0, exceedCount);
+							}
+						}
+						this.completeByNoMore(data, nomore, success);
+					})
+					return;
+				}
+			}
+			this.addData(data, success);
+		},
+		//简写，与completeByTotalCount完全相同
+		completeByTotal(data, totalCount, success = true) {
+			this.completeByTotalCount(data, totalCount, success);
+		},
+		//简写，与completeByTotalCount完全相同
+		endByTotalCount(data, totalCount, success = true) {
+			this.completeByTotalCount(data, totalCount, success);
+		},
+		//简写，与completeByTotalCount完全相同
+		endByTotal(data, totalCount, success = true) {
+			this.completeByTotalCount(data, totalCount, success);
+		},
+		//【自行判断是否有更多数据】请求结束(成功或者失败)调用此方法，将请求的结果传递给z-paging处理，第一个参数为请求结果数组，第二个参数为是否有更多数据，第三个参数为是否成功(默认是是）
+		completeByNoMore(data, nomore, success = true) {
+			if (nomore != 'undefined') {
+				this.customNoMore = nomore == true ? 1 : 0;
+			}
+			this.addData(data, success);
+		},
+		//简写，与completeByNoMore完全相同
+		endByNoMore(data, nomore, success = true) {
+			this.completeByNoMore(data, nomore, success);
+		},
+		//与上方complete方法功能一致，新版本中设置服务端回调数组请使用complete方法
+		addData(data, success = true) {
+			if (!this.fromCompleteEmit) {
+				this.disabledCompleteEmit = true;
+				this.fromCompleteEmit = false;
+			}
+			const currentTimeStamp = u.getTime();
+			let addDataDalay = 0;
+			const disTime = currentTimeStamp - this.requestTimeStamp;
+			let minDelay = this.minDelay;
+			if(this.isFirstPage && this.finalShowRefresherWhenReload){
+				minDelay = Math.max(400,minDelay);
+			}
+			if(this.requestTimeStamp > 0 && disTime < minDelay){
+				addDataDalay = minDelay - disTime;
+			}
+			this.$nextTick(() => {
+				let delay = this.delay > 0 ? this.delay : addDataDalay;
+				setTimeout(() => {
+					this._addData(data, success, false);
+				}, delay)
+			})
+		},
+		//从顶部添加数据，不会影响分页的pageNo和pageSize
+		addDataFromTop(data, toTop = true, toTopWithAnimate = true) {
+			let dataType = Object.prototype.toString.call(data);
+			if (dataType !== '[object Array]') {
+				data = [data];
+			}
+			this.totalData = [...data, ...this.totalData];
+			if (toTop) {
+				setTimeout(() => {
+					this._scrollToTop(toTopWithAnimate);
+				}, c.delayTime)
+			}
+		},
+		//重新设置列表数据，调用此方法不会影响pageNo和pageSize，也不会触发请求。适用场景：当需要删除列表中某一项时，将删除对应项后的数组通过此方法传递给z-paging。(当出现类似的需要修改列表数组的场景时，请使用此方法，请勿直接修改page中:list.sync绑定的数组)
+		resetTotalData(data) {
+			if (data == undefined) {
+				if (this.showConsoleError) {
+					u.consoleErr('方法resetTotalData参数缺失！');
+				}
+				return;
+			}
+			this.isTotalChangeFromAddData = true;
+			let dataType = Object.prototype.toString.call(data);
+			if (dataType !== '[object Array]') {
+				data = [data];
+			}
+			this.totalData = data;
+		},
+		//添加聊天记录
+		addChatRecordData(data, toBottom = true, toBottomWithAnimate = true) {
+			let dataType = Object.prototype.toString.call(data);
+			if (dataType !== '[object Array]') {
+				data = [data];
+			}
+			if (!this.useChatRecordMode) return;
+			this.isTotalChangeFromAddData = true;
+			//#ifndef APP-NVUE
+			this.totalData = [...this.totalData, ...data];
+			//#endif
+			//#ifdef APP-NVUE
+			this.totalData = this.nIsFirstPageAndNoMore ? [...this.totalData, ...data] : [...data, ...this.totalData];
+			//#endif
+			if (toBottom) {
+				setTimeout(() => {
+					//#ifndef APP-NVUE
+					this._scrollToBottom(toBottomWithAnimate);
+					//#endif
+					//#ifdef APP-NVUE
+					if (this.nIsFirstPageAndNoMore) {
+						this._scrollToBottom(toBottomWithAnimate);
+					} else {
+						this._scrollToTop(toBottomWithAnimate);
+					}
+					//#endif
+				}, c.delayTime)
+			}
+		},
+		//设置本地分页数据，请求结束(成功或者失败)调用此方法，将请求的结果传递给z-paging作分页处理（若调用了此方法，则上拉加载更多时内部会自动分页，不会触发@query所绑定的事件）
+		setLocalPaging(data, success = true) {
+			this.isLocalPaging = true;
+			this.$nextTick(() => {
+				this._addData(data, success, true);
+			})
+		},
+		//重新加载分页数据，pageNo会恢复为默认值，相当于下拉刷新的效果(animate为true时会展示下拉刷新动画，默认为false)
+		reload(animate = this.showRefresherWhenReload) {
+			if (animate) {
+				this.privateShowRefresherWhenReload = animate;
+				this.isUserPullDown = true;
+			}
+			this._preReload(animate, false);
+		},
+		//刷新列表数据，pageNo和pageSize不会重置，列表数据会重新从服务端获取。必须保证@query绑定的方法中的pageNo和pageSize和传给服务端的一致
+		refresh() {
+			if(!this.realTotalData.length){
+				this.reload();
+				return;
+			}
+			const disPageNo = this.pageNo - this.defaultPageNo + 1;
+			if (disPageNo >= 1) {
+				this.loading = true;
+				this.privateConcat = false;
+				const totalPageSize = disPageNo * this.pageSize;
+				this._emitQuery(this.defaultPageNo, totalPageSize, Enum.QueryFrom.Refresh);
+				this._callMyParentQuery(this.defaultPageNo, totalPageSize);
+			}
+		},
+		//清空分页数据
+		clean() {
+			this._reload(true);
+			this._addData([], true, false);
+		},
+		//清空分页数据
+		clear() {
+			this.clean();
+		},
+		//手动触发滚动到顶部加载更多，聊天记录模式时有效
+		doChatRecordLoadMore() {
+			this.useChatRecordMode && this._onLoadingMore('click');
+		},
+		//reload之前的一些处理
+		_preReload(animate = this.showRefresherWhenReload, isFromMounted = true) {
+			this.isUserReload = true;
+			this.loadingType = Enum.LoadingType.Refresher;
+			if (animate) {
+				this.privateShowRefresherWhenReload = animate;
+				// #ifndef APP-NVUE
+				if (this.useCustomRefresher) {
+					this._doRefresherRefreshAnimate();
+				} else {
+					this.refresherTriggered = true;
+				}
+				// #endif
+				// #ifdef APP-NVUE
+				this.refresherStatus = Enum.Refresher.Loading;
+				this.refresherRevealStackCount++;
+				setTimeout(() => {
+					this._getNodeClientRect('zp-n-refresh-container', false).then((node) => {
+						if (node) {
+							let nodeHeight = node[0].height;
+							this.nShowRefresherReveal = true;
+							this.nShowRefresherRevealHeight = nodeHeight;
+							setTimeout(() => {
+								this._nDoRefresherEndAnimation(0, -nodeHeight, false, false);
+								setTimeout(() => {
+									this._nDoRefresherEndAnimation(nodeHeight, 0);
+								}, 10)
+							}, 10)
+						}
+						this._reload(false, isFromMounted);
+						this._doRefresherLoad(false);
+					});
+				}, 10)
+				return;
+				// #endif
+			} else {
+				this._refresherEnd(false, false, false, false);
+			}
+			this._reload(false, isFromMounted);
+		},
+		//重新加载分页数据
+		_reload(isClean = false, isFromMounted = false, isUserPullDown = false) {
+			this.isAddedData = false;
+			this.cacheScrollNodeHeight = -1;
+			this.insideOfPaging = -1;
+			this.pageNo = this.defaultPageNo;
+			this._cleanRefresherEndTimeout();
+			!this.privateShowRefresherWhenReload && !isClean && this._startLoading(true);
+			this.firstPageLoaded = true;
+			this.isTotalChangeFromAddData = false;
+			this.totalData = [];
+			if (!isClean) {
+				this._emitQuery(this.pageNo, this.defaultPageSize, isUserPullDown ? Enum.QueryFrom.UserPullDown : Enum.QueryFrom.Reload);
+				let delay = 0;
+				// #ifdef MP-TOUTIAO
+				delay = 5;
+				// #endif
+				setTimeout(() => {
+					this._callMyParentQuery();
+				}, delay)
+				if (!isFromMounted && this.autoScrollToTopWhenReload) {
+					let checkedNRefresherLoading = true;
+					// #ifdef APP-NVUE
+					checkedNRefresherLoading = !this.nRefresherLoading;
+					// #endif
+					if (checkedNRefresherLoading) {
+						this._scrollToTop(false);
+					}
+				}
+				// #ifndef APP-NVUE
+				if (!this.usePageScroll && this.useChatRecordMode) {
+					if (this.showConsoleError) {
+						u.consoleWarn('使用聊天记录模式时，建议使用页面滚动，可将usePageScroll设置为true以启用页面滚动！！');
+					}
+				}
+				// #endif
+			}
+			this.$nextTick(() => {
+				// #ifdef APP-NVUE
+				this.nShowBottom = this.realTotalData.length > 0;
+				// #endif
+			})
+		},
+		//处理服务端返回的数组
+		_addData(data, success, isLocal) {
+			this.isAddedData = true;
+			this.fromEmptyViewReload = false;
+			this.isTotalChangeFromAddData = true;
+			this.refresherTriggered = false;
+			!this.useCustomRefresher && uni.stopPullDownRefresh();
+			// #ifdef APP-NVUE
+			this.usePageScroll && uni.stopPullDownRefresh();
+			// #endif
+			const tempIsUserPullDown = this.isUserPullDown;
+			if (this.showRefresherUpdateTime && this.isFirstPage) {
+				u.setRefesrherTime(u.getTime(), this.refresherUpdateTimeKey);
+				this.tempLanguageUpdateKey = u.getTime();
+				this.$refs.refresh && this.$refs.refresh.updateTime();
+			}
+			if (tempIsUserPullDown && this.isFirstPage) {
+				this.isUserPullDown = false;
+			}
+			let dataTypeRes = this._checkDataType(data, success, isLocal);
+			data = dataTypeRes.data;
+			success = dataTypeRes.success;
+			let delayTime = c.delayTime;
+			// #ifdef APP-NVUE
+			if (this.useChatRecordMode) delayTime = 0;
+			// #endif
+			this.loadingForNow = false;
+			setTimeout(() => {
+				this.pagingLoaded = true;
+				this.$nextTick(()=>{
+					this._refresherEnd(delayTime > 0, true, tempIsUserPullDown);
+				})
+			}, delayTime)
+			if (this.isFirstPage) {
+				this.isLoadFailed = !success;
+			}
+			if (success) {
+				if (!(this.privateConcat === false && this.loadingStatus === Enum.More.NoMore)) {
+					this.loadingStatus = Enum.More.Default;
+				}
+				if (isLocal) {
+					this.totalLocalPagingList = data;
+					this._localPagingQueryList(this.defaultPageNo, this.defaultPageSize, 0, (res) => {
+						this.complete(res);
+					})
+				} else {
+					let dataChangeDelayTime = 0;
+					// #ifdef APP-NVUE
+					if (this.privateShowRefresherWhenReload && this.finalNvueListIs === 'waterfall') {
+						dataChangeDelayTime = 150;
+					}
+					// #endif
+					setTimeout(() => {
+						this._currentDataChange(data, this.currentData);					
+					}, dataChangeDelayTime)
+				}
+			} else {
+				this._currentDataChange(data, this.currentData);
+				this.loadingStatus = Enum.More.Fail;
+				if (this.loadingType === Enum.LoadingType.LoadingMore) {
+					this.pageNo--;
+				}
+			}
+		},
+		//所有数据改变时调用
+		_totalDataChange(newVal, oldVal, eventThrow=true) {
+			if ((!this.isUserReload || !this.autoCleanListWhenReload) && this.firstPageLoaded && !newVal.length && oldVal.length) {
+				return;
+			}
+			this._doCheckScrollViewShouldFullHeight(newVal);
+			if(!this.realTotalData.length && !newVal.length){
+				eventThrow = false;
+			}
+			this.realTotalData = newVal;
+			if (eventThrow) {
+				this.$emit('input', newVal);
+				// #ifdef VUE3
+				this.$emit('update:modelValue', newVal);
+				// #endif
+				this.$emit('update:list', newVal);
+				this.$emit('listChange', newVal);
+				this._callMyParentList(newVal);
+			}
+			this.firstPageLoaded = false;
+			this.isTotalChangeFromAddData = false;
+			this.$nextTick(() => {
+				setTimeout(()=>{
+					this._getNodeClientRect('.zp-paging-container-content').then((res) => {
+						if (res) {
+							this.$emit('contentHeightChanged', res[0].height);
+						}
+					});
+				},this.isIos?100:300)
+				// #ifdef APP-NVUE
+				if (this.useChatRecordMode && this.nIsFirstPageAndNoMore && this.isFirstPage && !this.nFirstPageAndNoMoreChecked) {
+					this.nFirstPageAndNoMoreChecked = true;
+					this._scrollToBottom(false);
+				}
+				// #endif
+			})
+		},
+		//当前数据改变时调用
+		_currentDataChange(newVal, oldVal) {
+			newVal = [...newVal];
+			this.listRendering = true;
+			this.$nextTick(() => {
+				setTimeout(() => {
+					this.listRendering = false;
+				},50)
+			})
+			// #ifndef APP-NVUE
+			if (this.finalUseVirtualList) {
+				this._setCellIndex(newVal,this.totalData.length === 0);
+			}
+			this.useChatRecordMode && newVal.reverse();
+			// #endif
+			if (this.isFirstPage && this.finalConcat) {
+				this.totalData = [];
+			}
+			if (this.customNoMore !== -1) {
+				if (this.customNoMore === 0 || !newVal.length) {
+					this.loadingStatus = Enum.More.NoMore;
+				}
+			} else {
+				if (!newVal.length || (newVal.length && newVal.length < this.defaultPageSize)) {
+					this.loadingStatus = Enum.More.NoMore;
+				}
+			}
+			if (!this.totalData.length) {
+				if (this.finalConcat) {
+					// #ifdef APP-NVUE
+					if(this.useChatRecordMode && this.isFirstPage && this.loadingStatus === Enum.More.NoMore){
+						newVal.reverse();
+					}
+					// #endif
+					this.totalData = newVal;
+				}
+				if (this.useChatRecordMode) {
+					// #ifndef APP-NVUE
+					this.$nextTick(() => {
+						this._scrollToBottom(false);
+					})
+					// #endif
+				}
+			} else {
+				if (this.useChatRecordMode) {
+					// #ifdef APP-NVUE
+					this.totalData = [...this.totalData, ...newVal];
+					// #endif
+					//#ifndef APP-NVUE
+					const idIndex = newVal.length;
+					let idIndexStr = `z-paging-${idIndex}`;
+					this.totalData = [...newVal, ...this.totalData];
+					if (this.pageNo !== this.defaultPageNo) {
+						this.privateScrollWithAnimation = 0;
+						let delayTime = 200;
+						this.$emit('update:chatIndex', idIndex);
+						setTimeout(() => {
+							this._scrollIntoView(idIndexStr, 30 + this.cacheTopHeight, false, () => {
+								this.$emit('update:chatIndex', 0);
+							});
+						}, this.usePageScroll ? 0 : delayTime)
+					} else {
+						this.$nextTick(() => {
+							this._scrollToBottom(false);
+						})
+					}
+					//#endif
+		
+				} else {
+					if (this.finalConcat) {
+						const currentScrollTop = this.oldScrollTop;
+						this.totalData = [...this.totalData, ...newVal];
+						// #ifdef MP-WEIXIN
+						if (!this.isIos && !this.refresherOnly && !this.usePageScroll && newVal.length) {
+							this.loadingMoreTimeStamp = u.getTime();
+							this.$nextTick(()=>{
+								this.scrollToY(currentScrollTop);
+							})
+						}
+						// #endif
+					} else {
+						this.totalData = newVal;
+					}
+				}
+			}
+			this.privateConcat = true;
+		},
+		//本地分页请求
+		_localPagingQueryList(pageNo, pageSize, localPagingLoadingTime, callback) {
+			pageNo = parseInt(pageNo);
+			pageSize = parseInt(pageSize);
+			if (pageNo < 0 || pageSize <= 0) {
+				this._localPagingQueryResult(callback, [], localPagingLoadingTime);
+				return;
+			}
+			pageNo = Math.max(1,pageNo);
+			let totalPagingList = [...this.totalLocalPagingList];
+			let pageNoIndex = (pageNo - 1) * pageSize;
+			if (pageNoIndex + pageSize <= totalPagingList.length) {
+				this._localPagingQueryResult(callback, totalPagingList.splice(pageNoIndex, pageSize), localPagingLoadingTime);
+			} else if (pageNoIndex < totalPagingList.length) {
+				this._localPagingQueryResult(callback, totalPagingList.splice(pageNoIndex, totalPagingList.length - pageNoIndex), localPagingLoadingTime);
+			} else {
+				this._localPagingQueryResult(callback, [], localPagingLoadingTime);
+			}
+		},
+		//本地分页请求回调
+		_localPagingQueryResult(callback, arg, localPagingLoadingTime) {
+			setTimeout(() => {
+				callback(arg);
+			}, localPagingLoadingTime)
+		},
+		//修改父view的list
+		_callMyParentList(newVal) {
+			if (this.autowireListName.length) {
+				const myParent = u.getParent(this.$parent);
+				if (myParent && myParent[this.autowireListName]) {
+					myParent[this.autowireListName] = newVal;
+				}
+			}
+		},
+		//调用父view的query
+		_callMyParentQuery(customPageNo = 0, customPageSize = 0) {
+			if (this.autowireQueryName) {
+				if (this.myParentQuery === -1) {
+					const myParent = u.getParent(this.$parent);
+					if (myParent && myParent[this.autowireQueryName]) {
+						this.myParentQuery = myParent[this.autowireQueryName];
+					}
+				} 
+				if (this.myParentQuery !== -1) {
+					if (customPageSize > 0) {
+						this.myParentQuery(customPageNo, customPageSize);
+					} else {
+						this.myParentQuery(this.pageNo, this.defaultPageSize);
+					}
+				}
+			}
+		},
+		//发射query事件
+		_emitQuery(pageNo, pageSize, from){
+			this.requestTimeStamp = u.getTime();
+			this.$emit('query', ...interceptor._handleQuery(pageNo, pageSize, from));
+		},
+		//检查complete data的类型
+		_checkDataType(data, success, isLocal) {
+			const dataType = Object.prototype.toString.call(data);
+			if (dataType === '[object Boolean]') {
+				success = data;
+				data = [];
+			} else if (dataType === '[object Null]') {
+				data = [];
+			} else if (dataType !== '[object Array]') {
+				data = [];
+				let methodStr = isLocal ? 'setLocalPaging' : 'complete';
+				if (dataType !== '[object Undefined]') {
+					if (this.showConsoleError) {
+						u.consoleErr(`${methodStr}参数类型不正确，第一个参数类型必须为Array!`);
+					}
+				}
+			}
+			return {data,success};
+		},
+	}
+}
+
+export default ZPData;

components/z-paging/js/modules/empty.js

@@ -0,0 +1,150 @@
+// [z-paging]空数据图view模块
+import u from '.././z-paging-utils'
+
+const ZPEmptyView = {
+	props: {
+		//是否强制隐藏空数据图，默认为否
+		hideEmptyView: {
+			type: Boolean,
+			default: u.gc('hideEmptyView', false)
+		},
+		//空数据图描述文字，默认为“没有数据哦~”
+		emptyViewText: {
+			type: [String, Object],
+			default: u.gc('emptyViewText', null)
+		},
+		//是否显示空数据图重新加载按钮(无数据时)，默认为否
+		showEmptyViewReload: {
+			type: Boolean,
+			default: u.gc('showEmptyViewReload', false)
+		},
+		//加载失败时是否显示空数据图重新加载按钮，默认为是
+		showEmptyViewReloadWhenError: {
+			type: Boolean,
+			default: u.gc('showEmptyViewReloadWhenError', true)
+		},
+		//空数据图点击重新加载文字，默认为“重新加载”
+		emptyViewReloadText: {
+			type: [String, Object],
+			default: u.gc('emptyViewReloadText', null)
+		},
+		//空数据图图片，默认使用z-paging内置的图片
+		emptyViewImg: {
+			type: String,
+			default: u.gc('emptyViewImg', '')
+		},
+		//空数据图“加载失败”描述文字，默认为“很抱歉，加载失败”
+		emptyViewErrorText: {
+			type: [String, Object],
+			default: u.gc('emptyViewErrorText', null)
+		},
+		//空数据图“加载失败”图片，默认使用z-paging内置的图片
+		emptyViewErrorImg: {
+			type: String,
+			default: u.gc('emptyViewErrorImg', '')
+		},
+		//空数据图样式
+		emptyViewStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('emptyViewStyle', {});
+			}
+		},
+		//空数据图容器样式
+		emptyViewSuperStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('emptyViewSuperStyle', {});
+			}
+		},
+		//空数据图img样式
+		emptyViewImgStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('emptyViewImgStyle', {});
+			}
+		},
+		//空数据图描述文字样式
+		emptyViewTitleStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('emptyViewTitleStyle', {});
+			}
+		},
+		//空数据图重新加载按钮样式
+		emptyViewReloadStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('emptyViewReloadStyle', {});
+			}
+		},
+		//空数据图片是否铺满z-paging，默认为是。若设置为否，则为填充满z-paging的剩余部分
+		emptyViewFixed: {
+			type: Boolean,
+			default: function() {
+				return u.gc('emptyViewFixed', false)
+			}
+		},
+		//空数据图片是否垂直居中，默认为是。emptyViewFixed为false时有效
+		emptyViewCenter: {
+			type: Boolean,
+			default: function() {
+				return u.gc('emptyViewCenter', true)
+			}
+		},
+		//加载中时是否自动隐藏空数据图，默认为是
+		autoHideEmptyViewWhenLoading: {
+			type: Boolean,
+			default: u.gc('autoHideEmptyViewWhenLoading', true)
+		},
+		//用户下拉列表触发下拉刷新加载中时是否自动隐藏空数据图，默认为是
+		autoHideEmptyViewWhenPull: {
+			type: Boolean,
+			default: u.gc('autoHideEmptyViewWhenPull', true)
+		},
+		//空数据view的z-index，默认为9
+		emptyViewZIndex: {
+			type: Number,
+			default: u.gc('emptyViewZIndex', 9)
+		},
+	},
+	computed: {
+		finalEmptyViewImg() {
+			return this.isLoadFailed ? this.emptyViewErrorImg : this.emptyViewImg;
+		},
+		finalShowEmptyViewReload() {
+			return this.isLoadFailed ? this.showEmptyViewReloadWhenError : this.showEmptyViewReload;
+		},
+		showEmpty() {
+			if(this.refresherOnly || this.hideEmptyView || this.totalData.length) return false;
+			if(this.autoHideEmptyViewWhenLoading){
+				if (this.isAddedData && !this.firstPageLoaded && !this.loading) return true;
+			}else{
+				return true;
+			}
+			if (!this.autoHideEmptyViewWhenPull && !this.isUserReload) return true;
+			return false;
+		},
+	},
+	methods: {
+		//点击了空数据view重新加载按钮
+		_emptyViewReload() {
+			let callbacked = false;
+			this.$emit('emptyViewReload', (reload) => {
+				if (reload === undefined || reload === true) {
+					this.fromEmptyViewReload = true;
+					this.reload();
+				}
+				callbacked = true;
+			});
+			this.$nextTick(() => {
+				if (!callbacked) {
+					this.fromEmptyViewReload = true;
+					this.reload();
+				}
+			})
+		},
+	}
+}
+
+export default ZPEmptyView;

components/z-paging/js/modules/i18n.js

@@ -0,0 +1,98 @@
+// [z-paging]i18n模块
+import u from '.././z-paging-utils'
+import c from '.././z-paging-constant'
+import zI18n from '.././z-paging-i18n'
+
+const systemInfo = uni.getSystemInfoSync();
+const ZPI18n = {
+	props: {
+		//i18n国际化设置语言，支持简体中文(zh-cn)、繁体中文(zh-hant-cn)和英文(en)
+		language: {
+			type: String,
+			default: u.gc('language', '')
+		},
+		//i18n国际化默认是否跟随系统语言，默认为是
+		followSystemLanguage: {
+			type: Boolean,
+			default: u.gc('followSystemLanguage', true)
+		},
+	},
+	data() {
+		return {
+			tempLanguageUpdateKey: 0,
+		}
+	},
+	computed: {
+		tempLanguage() {
+			let systemLanguage = false;
+			const temp = this.tempLanguageUpdateKey;
+			if (this.followSystemLanguage) {
+				systemLanguage = systemInfo.language;
+			}
+			return uni.getStorageSync(c.i18nUpdateKey) || systemLanguage || 'zh-cn';
+		},
+		finalTempLanguage() {
+			return this.language.length ? this.language : this.tempLanguage;
+		},
+		finalLanguage() {
+			let language = this.finalTempLanguage.toLowerCase();
+			return zI18n._getPrivateLanguage(language, this.followSystemLanguage);
+		},
+		finalRefresherDefaultText() {
+			return this._getI18nText('refresherDefaultText', this.refresherDefaultText);
+		},
+		finalRefresherPullingText() {
+			return this._getI18nText('refresherPullingText', this.refresherPullingText);
+		},
+		finalRefresherRefreshingText() {
+			return this._getI18nText('refresherRefreshingText', this.refresherRefreshingText);
+		},
+		finalRefresherCompleteText() {
+			return this._getI18nText('refresherCompleteText', this.refresherCompleteText);
+		},
+		finalLoadingMoreDefaultText() {
+			return this._getI18nText('loadingMoreDefaultText', this.loadingMoreDefaultText);
+		},
+		finalLoadingMoreLoadingText() {
+			return this._getI18nText('loadingMoreLoadingText', this.loadingMoreLoadingText);
+		},
+		finalLoadingMoreNoMoreText() {
+			return this._getI18nText('loadingMoreNoMoreText', this.loadingMoreNoMoreText);
+		},
+		finalLoadingMoreFailText() {
+			return this._getI18nText('loadingMoreFailText', this.loadingMoreFailText);
+		},
+		finalEmptyViewText() {
+			return this.isLoadFailed ? this.finalEmptyViewErrorText : this._getI18nText('emptyViewText', this.emptyViewText);
+		},
+		finalEmptyViewReloadText() {
+			return this._getI18nText('emptyViewReloadText', this.emptyViewReloadText);
+		},
+		finalEmptyViewErrorText() {
+			return this._getI18nText('emptyViewErrorText', this.emptyViewErrorText);
+		},
+	},
+	methods: {
+		//设置i18n国际化语言
+		setI18n(language) {
+			zI18n.setLanguage(language);
+		},
+		//获取当前z-paging的语言
+		getLanguage() {
+			return this.finalLanguage;
+		},
+		//获取国际化转换后的文本
+		_getI18nText(key, value) {
+			const dataType = Object.prototype.toString.call(value);
+			if (dataType === '[object Object]') {
+				const nextValue = value[this.finalLanguage];
+				if (nextValue) return nextValue;
+			} else if (dataType === '[object String]') {
+				return value;
+			}
+			return zI18n.t[key][this.finalLanguage];
+		},
+	}
+}
+
+export default ZPI18n;

components/z-paging/js/modules/load-more.js

@@ -0,0 +1,328 @@
+// [z-paging]滚动到底部加载更多模块
+import u from '.././z-paging-utils'
+import Enum from '.././z-paging-enum'
+
+const ZPLoadMore = {
+	props: {
+		//自定义底部加载更多样式
+		loadingMoreCustomStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('loadingMoreCustomStyle', {});
+			}
+		},
+		//自定义底部加载更多文字样式
+		loadingMoreTitleCustomStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('loadingMoreTitleCustomStyle', {});
+			}
+		},
+		//自定义底部加载更多加载中动画样式
+		loadingMoreLoadingIconCustomStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('loadingMoreLoadingIconCustomStyle', {});
+			}
+		},
+		//自定义底部加载更多加载中动画图标类型，可选flower或circle，默认为flower
+		loadingMoreLoadingIconType: {
+			type: String,
+			default: u.gc('loadingMoreLoadingIconType', 'flower')
+		},
+		//自定义底部加载更多加载中动画图标图片
+		loadingMoreLoadingIconCustomImage: {
+			type: String,
+			default: u.gc('loadingMoreLoadingIconCustomImage', '')
+		},
+		//底部加载更多加载中view是否展示旋转动画，默认为是
+		loadingMoreLoadingAnimated: {
+			type: Boolean,
+			default: u.gc('loadingMoreLoadingAnimated', true)
+		},
+		//是否启用加载更多数据(含滑动到底部加载更多数据和点击加载更多数据)，默认为是
+		loadingMoreEnabled: {
+			type: Boolean,
+			default: u.gc('loadingMoreEnabled', true)
+		},
+		//是否启用滑动到底部加载更多数据，默认为是
+		toBottomLoadingMoreEnabled: {
+			type: Boolean,
+			default: u.gc('toBottomLoadingMoreEnabled', true)
+		},
+		//滑动到底部状态为默认状态时，以加载中的状态展示，默认为否。若设置为是，可避免滚动到底部看到默认状态然后立刻变为加载中状态的问题，但分页数量未超过一屏时，不会显示【点击加载更多】
+		loadingMoreDefaultAsLoading: {
+			type: [Boolean],
+			default: u.gc('loadingMoreDefaultAsLoading', false)
+		},
+		//滑动到底部"默认"文字，默认为【点击加载更多】
+		loadingMoreDefaultText: {
+			type: [String, Object],
+			default: u.gc('loadingMoreDefaultText', null)
+		},
+		//滑动到底部"加载中"文字，默认为【正在加载...】
+		loadingMoreLoadingText: {
+			type: [String, Object],
+			default: u.gc('loadingMoreLoadingText', null)
+		},
+		//滑动到底部"没有更多"文字，默认为【没有更多了】
+		loadingMoreNoMoreText: {
+			type: [String, Object],
+			default: u.gc('loadingMoreNoMoreText', null)
+		},
+		//滑动到底部"加载失败"文字，默认为【加载失败，点击重新加载】
+		loadingMoreFailText: {
+			type: [String, Object],
+			default: u.gc('loadingMoreFailText', null)
+		},
+		//当没有更多数据且分页内容未超出z-paging时是否隐藏没有更多数据的view，默认为否
+		hideLoadingMoreWhenNoMoreAndInsideOfPaging: {
+			type: Boolean,
+			default: u.gc('hideLoadingMoreWhenNoMoreAndInsideOfPaging', false)
+		},
+		//当没有更多数据且分页数组长度少于这个值时，隐藏没有更多数据的view，默认为0，代表不限制。
+		hideLoadingMoreWhenNoMoreByLimit: {
+			type: Number,
+			default: u.gc('hideLoadingMoreWhenNoMoreByLimit', 0)
+		},
+		//是否显示默认的加载更多text，默认为是
+		showDefaultLoadingMoreText: {
+			type: Boolean,
+			default: u.gc('showDefaultLoadingMoreText', true)
+		},
+		//是否显示没有更多数据的view
+		showLoadingMoreNoMoreView: {
+			type: Boolean,
+			default: u.gc('showLoadingMoreNoMoreView', true)
+		},
+		//是否显示没有更多数据的分割线，默认为是
+		showLoadingMoreNoMoreLine: {
+			type: Boolean,
+			default: u.gc('showLoadingMoreNoMoreLine', true)
+		},
+		//自定义底部没有更多数据的分割线样式
+		loadingMoreNoMoreLineCustomStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('loadingMoreNoMoreLineCustomStyle', {});
+			},
+		},
+		//距底部/右边多远时（单位px），触发 scrolltolower 事件，默认为100rpx
+		lowerThreshold: {
+			type: [Number, String],
+			default: u.gc('lowerThreshold', '100rpx')
+		},
+	},
+	data() {
+		return {
+			//底部加载更多状态
+			loadingStatus: Enum.More.Default,
+			loadingStatusAfterRender: Enum.More.Default,
+			loadingMoreTimeStamp: 0,
+			loadingMoreDefaultSlot: null,
+			showLoadingMore: false,
+			customNoMore: -1,
+		}
+	},
+	computed: {
+		zPagingLoadMoreConfig() {
+			return {
+				status: this.loadingStatusAfterRender,
+				defaultAsLoading: this.loadingMoreDefaultAsLoading,
+				defaultThemeStyle: this.finalLoadingMoreThemeStyle,
+				customStyle: this.loadingMoreCustomStyle,
+				titleCustomStyle: this.loadingMoreTitleCustomStyle,
+				iconCustomStyle: this.loadingMoreLoadingIconCustomStyle,
+				loadingIconType: this.loadingMoreLoadingIconType,
+				loadingIconCustomImage: this.loadingMoreLoadingIconCustomImage,
+				loadingAnimated: this.loadingMoreLoadingAnimated,
+				showNoMoreLine: this.showLoadingMoreNoMoreLine,
+				noMoreLineCustomStyle: this.loadingMoreNoMoreLineCustomStyle,
+				defaultText: this.finalLoadingMoreDefaultText,
+				loadingText: this.finalLoadingMoreLoadingText,
+				noMoreText: this.finalLoadingMoreNoMoreText,
+				failText: this.finalLoadingMoreFailText,
+				hideContent: !this.loadingMoreDefaultAsLoading && this.listRendering
+			};
+		},
+		finalLoadingMoreThemeStyle() {
+			return this.loadingMoreThemeStyle.length ? this.loadingMoreThemeStyle : this.defaultThemeStyle;
+		},
+		showLoadingMoreDefault() {
+			return this._showLoadingMore('Default');
+		},
+		showLoadingMoreLoading() {
+			return this._showLoadingMore('Loading');
+		},
+		showLoadingMoreNoMore() {
+			return this._showLoadingMore('NoMore');
+		},
+		showLoadingMoreFail() {
+			return this._showLoadingMore('Fail');
+		},
+		showLoadingMoreCustom() {
+			return this._showLoadingMore('Custom');
+		}
+	},
+	methods: {
+		//手动触发上拉加载更多(非必须，可依据具体需求使用)
+		doLoadMore(type) {
+			this._onLoadingMore(type);
+		},
+		//通过@scroll事件检测是否滚动到了底部
+		_checkScrolledToBottom(scrollDiff, checked = false) {
+			if (this.checkScrolledToBottomTimeOut) {
+				clearTimeout(this.checkScrolledToBottomTimeOut);
+				this.checkScrolledToBottomTimeOut = null;
+			}
+			if (this.cacheScrollNodeHeight === -1) {
+				this._getNodeClientRect('.zp-scroll-view').then((res) => {
+					if (res) {
+						let pageScrollNodeHeight = res[0].height;
+						this.cacheScrollNodeHeight = pageScrollNodeHeight;
+						if (scrollDiff - pageScrollNodeHeight <= this.finalLowerThreshold) {
+							this._onLoadingMore('toBottom');
+						}
+					}
+				});
+			} else {
+				if (scrollDiff - this.cacheScrollNodeHeight <= this.finalLowerThreshold) {
+					this._onLoadingMore('toBottom');
+				} else if (scrollDiff - this.cacheScrollNodeHeight <= 500 && !checked) {
+					this.checkScrolledToBottomTimeOut = setTimeout(() => {
+						this._getNodeClientRect('.zp-scroll-view', true, true).then((res) => {
+							this.oldScrollTop = res[0].scrollTop;
+							const newScrollDiff = res[0].scrollHeight - this.oldScrollTop;
+							this._checkScrolledToBottom(newScrollDiff, true);
+						})
+					}, 150)
+				}
+			}
+		},
+		//触发加载更多时调用,from:0-滑动到底部触发；1-点击加载更多触发
+		_onLoadingMore(from = 'click') {
+			if (from === 'toBottom') {
+				if (!this.scrollToBottomBounceEnabled) {
+					if (this.scrollEnable) {
+						this.scrollEnable = false;
+						this.$nextTick(() => {
+							this.scrollEnable = true;
+						})
+					}
+				}
+				//#ifdef APP-VUE || H5
+				if (this.isIos) {
+					this.renderPropUsePageScroll = -1;
+					this.$nextTick(() => {
+						this.renderPropUsePageScroll = this.usePageScroll;
+					})
+				}
+				//#endif
+			}
+			this.$emit('scrolltolower', from);
+			if (from === 'toBottom' && (!this.toBottomLoadingMoreEnabled || this.useChatRecordMode)) return;
+			if (this.refresherOnly || !this.loadingMoreEnabled || !(this.loadingStatus === Enum.More.Default || this.loadingStatus === Enum.More.Fail) || this.loading) return;
+			// #ifdef MP-WEIXIN
+			if (!this.isIos && !this.refresherOnly && !this.usePageScroll) {
+				const currentTimestamp = u.getTime();
+				if (this.loadingMoreTimeStamp > 0 && currentTimestamp - this.loadingMoreTimeStamp < 100) {
+					this.loadingMoreTimeStamp = 0;
+					return;
+				}
+			}
+			// #endif
+			this._doLoadingMore();
+		},
+		//处理开始加载更多
+		_doLoadingMore() {
+			if (this.pageNo >= this.defaultPageNo && this.loadingStatus !== Enum.More.NoMore) {
+				this.pageNo++;
+				this._startLoading(false);
+				if (this.isLocalPaging) {
+					this._localPagingQueryList(this.pageNo, this.defaultPageSize, this.localPagingLoadingTime, (res) => {
+						this.addData(res);
+					})
+				} else {
+					this._emitQuery(this.pageNo, this.defaultPageSize, Enum.QueryFrom.LoadingMore);
+					this._callMyParentQuery();
+				}
+				this.loadingType = Enum.LoadingType.LoadingMore;
+			}
+		},
+		//(预处理)判断当没有更多数据且分页内容未超出z-paging时是否显示没有更多数据的view
+		_preCheckShowLoadingMoreWhenNoMoreAndInsideOfPaging(newVal, scrollViewNode, pagingContainerNode) {
+			if (this.loadingStatus === Enum.More.NoMore && this.hideLoadingMoreWhenNoMoreByLimit > 0 && newVal.length) {
+				this.showLoadingMore = newVal.length > this.hideLoadingMoreWhenNoMoreByLimit;
+			} else if ((this.loadingStatus === Enum.More.NoMore && this.hideLoadingMoreWhenNoMoreAndInsideOfPaging && newVal.length) || (this.insideMore && this.insideOfPaging !== false && newVal.length)) {
+				this.$nextTick(() => {
+					this._checkShowLoadingMoreWhenNoMoreAndInsideOfPaging(newVal, scrollViewNode, pagingContainerNode);
+				})
+				if (this.insideMore && this.insideOfPaging !== false && newVal.length) {
+					this.showLoadingMore = newVal.length;
+				}
+			} else {
+				this.showLoadingMore = newVal.length;
+			}
+		},
+		//判断当没有更多数据且分页内容未超出z-paging时是否显示没有更多数据的view
+		async _checkShowLoadingMoreWhenNoMoreAndInsideOfPaging(totalData, oldScrollViewNode, oldPagingContainerNode) {
+			try {
+				const scrollViewNode = oldScrollViewNode || await this._getNodeClientRect('.zp-scroll-view');
+				if (this.usePageScroll) {
+					if (scrollViewNode) {
+						const scrollViewTotalH = scrollViewNode[0].top + scrollViewNode[0].height;
+						this.insideOfPaging = scrollViewTotalH < this.windowHeight;
+						if (this.hideLoadingMoreWhenNoMoreAndInsideOfPaging) {
+							this.showLoadingMore = !this.insideOfPaging;
+						}
+						this._updateInsideOfPaging();
+					}
+				} else {
+					let pagingContainerH = 0;
+					let scrollViewH = 0;
+					const pagingContainerNode = oldPagingContainerNode || await this._getNodeClientRect('.zp-paging-container-content');
+					if (pagingContainerNode) {
+						pagingContainerH = pagingContainerNode[0].height;
+					}
+					if (scrollViewNode) {
+						scrollViewH = scrollViewNode[0].height;
+					}
+					this.insideOfPaging = pagingContainerH < scrollViewH;
+					if (this.hideLoadingMoreWhenNoMoreAndInsideOfPaging) {
+						this.showLoadingMore = !this.insideOfPaging;
+					}
+					this._updateInsideOfPaging();
+				}
+			} catch (e) {
+				this.insideOfPaging = !totalData.length;
+				if (this.hideLoadingMoreWhenNoMoreAndInsideOfPaging) {
+					this.showLoadingMore = !this.insideOfPaging;
+				}
+				this._updateInsideOfPaging();
+			}
+		},
+		//是否要展示上拉加载更多view
+		_showLoadingMore(type) {
+			if (!(this.loadingStatus === Enum.More.Default ? this.nShowBottom : true) || !this.totalData.length) return false;
+			if (((!this.showLoadingMoreWhenReload || this.isUserPullDown || this.loadingStatus !== Enum.More.Loading) && !this.showLoadingMore) || 
+			(!this.loadingMoreEnabled && (!this.showLoadingMoreWhenReload || this.isUserPullDown || this.loadingStatus !== Enum.More.Loading)) || 
+			this.refresherOnly) return false;
+			if (this.useChatRecordMode && type !== 'Loading') return false;
+			if (!this.$slots) return false;
+			if (type === 'Custom') {
+				return this.showDefaultLoadingMoreText && !(this.loadingStatus === Enum.More.NoMore && !this.showLoadingMoreNoMoreView);
+			}
+			const res = this.loadingStatus === Enum.More[type] && this.$slots[`loadingMore${type}`] && (type === 'NoMore' ? this.showLoadingMoreNoMoreView : true);
+			if (res) {
+				// #ifdef APP-NVUE
+				if (!this.isIos) {
+					this.nLoadingMoreFixedHeight = false;
+				}
+				//  #endif
+			}
+			return res;
+		},
+	}
+}
+
+export default ZPLoadMore;

components/z-paging/js/modules/nvue.js

@@ -0,0 +1,219 @@
+// [z-paging]nvue独有部分模块
+import u from '.././z-paging-utils'
+import Enum from '.././z-paging-enum'
+
+// #ifdef APP-NVUE
+const weexAnimation = weex.requireModule('animation');
+// #endif
+const ZPNvue = {
+	props: {
+		//nvue中修改列表类型，可选值有list、waterfall和scroller，默认为list
+		nvueListIs: {
+			type: String,
+			default: u.gc('nvueListIs', 'list')
+		},
+		//nvue waterfall配置，仅在nvue中且nvueListIs=waterfall时有效，配置参数详情参见：https://uniapp.dcloud.io/component/waterfall
+		nvueWaterfallConfig: {
+			type: Object,
+			default: function() {
+				return u.gc('nvueWaterfallConfig', {});
+			}
+		},
+		//nvue 控制是否回弹效果，iOS不支持动态修改
+		nvueBounce: {
+			type: Boolean,
+			default: u.gc('nvueBounce', true)
+		},
+		//nvue中通过代码滚动到顶部/底部时，是否加快动画效果(无滚动动画时无效)，默认为否
+		nvueFastScroll: {
+			type: Boolean,
+			default: u.gc('nvueFastScroll', false)
+		},
+		//nvue中list的id
+		nvueListId: {
+			type: String,
+			default: u.gc('nvueListId', '')
+		},
+		//nvue中refresh组件的样式
+		nvueRefresherStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('nvueRefresherStyle', {});
+			}
+		},
+		//nvue中是否按分页模式(类似竖向swiper)显示List，默认为false
+		nvuePagingEnabled: {
+			type: Boolean,
+			default: u.gc('nvuePagingEnabled', false)
+		},
+		//是否隐藏nvue列表底部的tagView，此view用于标识滚动到底部位置，若隐藏则滚动到底部功能将失效，在nvue中实现吸顶+swiper功能时需将最外层z-paging的此属性设置为true。默认为否
+		hideNvueBottomTag: {
+			type: Boolean,
+			default: u.gc('hideNvueBottomTag', false)
+		},
+	},
+	data() {
+		return {
+			nRefresherLoading: false,
+			nListIsDragging: false,
+			nShowBottom: true,
+			nFixFreezing: false,
+			nShowRefresherReveal: false,
+			nIsFirstPageAndNoMore: false,
+			nFirstPageAndNoMoreChecked: false,
+			nLoadingMoreFixedHeight: false,
+			nShowRefresherRevealHeight: 0,
+			nRefresherWidth: uni.upx2px(750),
+		}
+	},
+	watch: {
+		nIsFirstPageAndNoMore: {
+			handler(newVal) {
+				const cellStyle = !this.useChatRecordMode || newVal ? {} : {transform: 'rotate(180deg)'};
+				this.$emit('update:cellStyle', cellStyle);
+			},
+			immediate: true
+		}
+	},
+	computed: {
+		// #ifdef APP-NVUE
+		nWaterfallColumnCount() {
+			if (this.finalNvueListIs !== 'waterfall') return 0;
+			return this._nGetWaterfallConfig('column-count', 2);
+		},
+		nWaterfallColumnWidth() {
+			return this._nGetWaterfallConfig('column-width', 'auto');
+		},
+		nWaterfallColumnGap() {
+			return this._nGetWaterfallConfig('column-gap', 'normal');
+		},
+		nWaterfallLeftGap() {
+			return this._nGetWaterfallConfig('left-gap', 0);
+		},
+		nWaterfallRightGap() {
+			return this._nGetWaterfallConfig('right-gap', 0);
+		},
+		nViewIs() {
+			const is = this.finalNvueListIs;
+			return is === 'scroller' || is === 'view' ? 'view' : is === 'waterfall' ? 'header' : 'cell';
+		},
+		nSafeAreaBottomHeight() {
+			return this.safeAreaInsetBottom ? this.safeAreaBottom : 0;
+		},
+		finalNvueListIs() {
+			if (this.usePageScroll) return 'view';
+			const nvueListIsLowerCase = this.nvueListIs.toLowerCase();
+			if (['list','waterfall','scroller'].indexOf(nvueListIsLowerCase) !== -1) {
+				return nvueListIsLowerCase;
+			}
+			return 'list';
+		},
+		finalNvueSuperListIs() {
+			return this.usePageScroll ? 'view' : 'scroller';
+		},
+		finalNvueRefresherEnabled() {
+			return this.finalNvueListIs !== 'view' && this.finalRefresherEnabled && !this.nShowRefresherReveal && !this.useChatRecordMode;
+		},
+		// #endif
+	},
+	methods: {
+		// #ifdef APP-NVUE
+		//列表滚动时触发
+		_nOnScroll(e) {
+			this.$emit('scroll', e);
+			const contentOffsetY = e.contentOffset.y;
+			this.nListIsDragging = e.isDragging;
+			this._checkShouldShowBackToTop(-e.contentOffset.y, -e.contentOffset.y - 1);
+		},
+		//下拉刷新刷新中
+		_nOnRrefresh() {
+			if (this.nShowRefresherReveal) return;
+			this.nRefresherLoading = true;
+			this.refresherStatus = Enum.Refresher.Loading;
+			this._doRefresherLoad();
+		},
+		//下拉刷新下拉中
+		_nOnPullingdown(e) {
+			if (this.refresherStatus === Enum.Refresher.Loading || (this.isIos && !this.nListIsDragging)) return;
+			this._emitTouchmove(e);
+			const viewHeight = e.viewHeight;
+			const pullingDis = e.pullingDistance;
+			this.refresherStatus = pullingDis >= viewHeight ? Enum.Refresher.ReleaseToRefresh : Enum.Refresher.Default;
+		},
+		//下拉刷新结束
+		_nRefresherEnd(doEnd=true) {
+			if (doEnd) {
+			   this._nDoRefresherEndAnimation(0, -this.nShowRefresherRevealHeight); 
+			   !this.usePageScroll && this.$refs['zp-n-list'].resetLoadmore();
+			   this.nRefresherLoading = false;
+			}
+			this.$nextTick(() => {
+				setTimeout(()=> {
+					this.nShowBottom = true;
+				}, 10);
+			})
+		},
+		//执行主动触发下拉刷新动画
+		_nDoRefresherEndAnimation(height, translateY, animate = true, checkStack = true) {
+			this._cleanRefresherCompleteTimeout();
+			this._cleanRefresherEndTimeout();
+			if (!this.finalShowRefresherWhenReload) {
+				this.refresherEndTimeout = setTimeout(() => {
+					this.refresherStatus = Enum.Refresher.Default;
+				}, this.refresherCompleteDuration);
+				return;
+			}
+			const stackCount = this.refresherRevealStackCount;
+			if (height === 0 && checkStack) {
+				this.refresherRevealStackCount--;
+				if (stackCount > 1) return;
+				this.refresherEndTimeout = setTimeout(() => {
+					this.refresherStatus = Enum.Refresher.Default;
+				}, this.refresherCompleteDuration);
+			}
+			if (stackCount > 1) {
+				this.refresherStatus = Enum.Refresher.Loading;
+			}
+			const duration = animate ? 120 : 0;
+			weexAnimation.transition(this.$refs['zp-n-list-refresher-reveal'], {
+				styles: {
+					height: `${height}px`,
+					transform: `translateY(${translateY}px)`,
+				},
+				duration: duration,
+				timingFunction: 'linear',
+				needLayout: true,
+				delay: 0
+			})
+			setTimeout(() => {
+				if (animate) {
+					this.nShowRefresherReveal = height > 0;
+				}
+			}, duration > 0 ? duration - 100 : 0);
+		},
+		//滚动到底部加载更多
+		_nOnLoadmore() {
+			if (this.nShowRefresherReveal || !this.totalData.length) return;
+			this.useChatRecordMode ? this.doChatRecordLoadMore() : this._onLoadingMore('toBottom');
+		},
+		//获取nvue waterfall单项配置
+		_nGetWaterfallConfig(key, defaultValue) {
+			return this.nvueWaterfallConfig[key] || defaultValue;
+		},
+		//更新nvue 下拉刷新view容器的宽度
+		_nUpdateRefresherWidth() {
+			this.$nextTick(()=>{
+				this._getNodeClientRect('.zp-n-list').then(node => {
+					if (node) {
+						const nodeWidth = node[0].width;
+						this.nRefresherWidth = nodeWidth;
+					}
+				})
+			})
+			
+		}
+		// #endif
+	}
+}
+
+export default ZPNvue;

components/z-paging/js/modules/refresher.js

@@ -0,0 +1,632 @@
+// [z-paging]下拉刷新view模块
+import u from '.././z-paging-utils'
+import c from '.././z-paging-constant'
+import Enum from '.././z-paging-enum'
+
+const ZPRefresher = {
+	props: {
+		//下拉刷新的主题样式，支持black，white，默认black
+		refresherThemeStyle: {
+			type: String,
+			default: function() {
+				return u.gc('refresherThemeStyle', '');
+			}
+		},
+		//自定义下拉刷新中左侧图标的样式
+		refresherImgStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('refresherImgStyle', {});
+			}
+		},
+		//自定义下拉刷新中右侧状态描述文字的样式
+		refresherTitleStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('refresherTitleStyle', {});
+			}
+		},
+		//自定义下拉刷新中右侧最后更新时间文字的样式(show-refresher-update-time为true时有效)
+		refresherUpdateTimeStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('refresherUpdateTimeStyle', {});
+			}
+		},
+		//在微信小程序和QQ小程序中，是否实时监听下拉刷新中进度，默认为否
+		watchRefresherTouchmove: {
+			type: Boolean,
+			default: u.gc('watchRefresherTouchmove', false)
+		},
+		//底部加载更多的主题样式，支持black，white，默认black
+		loadingMoreThemeStyle: {
+			type: String,
+			default: function() {
+				return u.gc('loadingMoreThemeStyle', '');
+			}
+		},
+		//是否只使用下拉刷新，设置为true后将关闭mounted自动请求数据、关闭滚动到底部加载更多，强制隐藏空数据图。默认为否
+		refresherOnly: {
+			type: Boolean,
+			default: u.gc('refresherOnly', false)
+		},
+		//自定义下拉刷新默认状态下回弹动画时间，单位为毫秒，默认为100毫秒，nvue无效
+		refresherDefaultDuration: {
+			type: [Number, String],
+			default: u.gc('refresherDefaultDuration', 100)
+		},
+		//自定义下拉刷新结束以后延迟回弹的时间，单位为毫秒，默认为0
+		refresherCompleteDelay: {
+			type: [Number, String],
+			default: u.gc('refresherCompleteDelay', 0)
+		},
+		//自定义下拉刷新结束回弹动画时间，单位为毫秒，默认为300毫秒(refresherEndBounceEnabled为false时，refresherCompleteDuration为设定值的1/3)，nvue无效
+		refresherCompleteDuration: {
+			type: [Number, String],
+			default: u.gc('refresherCompleteDuration', 300)
+		},
+		//自定义下拉刷新结束状态下是否允许列表滚动，默认为否
+		refresherCompleteScrollable: {
+			type: Boolean,
+			default: u.gc('refresherCompleteScrollable', false)
+		},
+		//是否使用自定义的下拉刷新，默认为是，即使用z-paging的下拉刷新。设置为false即代表使用uni scroll-view自带的下拉刷新，h5、App、微信小程序以外的平台不支持uni scroll-view自带的下拉刷新
+		useCustomRefresher: {
+			type: Boolean,
+			default: u.gc('useCustomRefresher', true)
+		},
+		//自定义下拉刷新下拉帧率，默认为40，过高可能会出现抖动问题
+		refresherFps: {
+			type: [Number, String],
+			default: u.gc('refresherFps', 40)
+		},
+		//自定义下拉刷新允许触发的最大下拉角度，默认为40度，当下拉角度小于设定值时，自定义下拉刷新动画不会被触发
+		refresherMaxAngle: {
+			type: [Number, String],
+			default: u.gc('refresherMaxAngle', 40)
+		},
+		//自定义下拉刷新的角度由未达到最大角度变到达到最大角度时，是否继续下拉刷新手势，默认为否
+		refresherAngleEnableChangeContinued: {
+			type: Boolean,
+			default: u.gc('refresherAngleEnableChangeContinued', false)
+		},
+		//自定义下拉刷新默认状态下的文字
+		refresherDefaultText: {
+			type: [String, Object],
+			default: u.gc('refresherDefaultText', null)
+		},
+		//自定义下拉刷新松手立即刷新状态下的文字
+		refresherPullingText: {
+			type: [String, Object],
+			default: u.gc('refresherPullingText', null)
+		},
+		//自定义下拉刷新刷新中状态下的文字
+		refresherRefreshingText: {
+			type: [String, Object],
+			default: u.gc('refresherRefreshingText', null)
+		},
+		//自定义下拉刷新刷新结束状态下的文字
+		refresherCompleteText: {
+			type: [String, Object],
+			default: u.gc('refresherCompleteText', null)
+		},
+		//是否开启自定义下拉刷新刷新结束回弹效果，默认为是
+		refresherEndBounceEnabled: {
+			type: Boolean,
+			default: u.gc('refresherEndBounceEnabled', true)
+		},
+		//是否开启自定义下拉刷新，默认为是
+		refresherEnabled: {
+			type: Boolean,
+			default: u.gc('refresherEnabled', true)
+		},
+		//设置自定义下拉刷新阈值，默认为80rpx
+		refresherThreshold: {
+			type: [Number, String],
+			default: u.gc('refresherThreshold', '80rpx')
+		},
+		//设置系统下拉刷新默认样式，支持设置 black，white，none，none 表示不使用默认样式，默认为black
+		refresherDefaultStyle: {
+			type: String,
+			default: u.gc('refresherDefaultStyle', 'black')
+		},
+		//设置自定义下拉刷新区域背景
+		refresherBackground: {
+			type: String,
+			default: u.gc('refresherBackground', 'transparent')
+		},
+		//设置固定的自定义下拉刷新区域背景
+		refresherFixedBackground: {
+			type: String,
+			default: u.gc('refresherFixedBackground', 'transparent')
+		},
+		//设置固定的自定义下拉刷新区域高度，默认为0
+		refresherFixedBacHeight: {
+			type: [Number, String],
+			default: u.gc('refresherFixedBacHeight', 0)
+		},
+		//设置自定义下拉刷新下拉超出阈值后继续下拉位移衰减的比例，范围0-1，值越大代表衰减越多。默认为0.7(nvue无效)
+		refresherOutRate: {
+			type: Number,
+			default: u.gc('refresherOutRate', 0.7)
+		},
+		//是否显示最后更新时间，默认为否
+		showRefresherUpdateTime: {
+			type: Boolean,
+			default: u.gc('showRefresherUpdateTime', false)
+		},
+		//如果需要区别不同页面的最后更新时间，请为不同页面的z-paging的`refresher-update-time-key`设置不同的字符串
+		refresherUpdateTimeKey: {
+			type: String,
+			default: u.gc('refresherUpdateTimeKey', 'default')
+		},
+	},
+	data() {
+		return {
+			//下拉刷新状态
+			refresherStatus: Enum.Refresher.Default,
+			refresherTouchstartY: 0,
+			lastRefresherTouchmove: null,
+			refresherReachMaxAngle: true,
+			refresherTransform: 'translateY(0px)',
+			refresherTransition: '',
+			finalRefresherDefaultStyle: 'black',
+			refresherRevealStackCount: 0,
+			refresherCompleteTimeout: null,
+			refresherCompleteSubTimeout: null,
+			refresherEndTimeout: null,
+			isTouchmovingTimeout: null,
+			refresherTriggered: false,
+			isTouchmoving: false,
+			isTouchEnded: false,
+			isUserPullDown: false,
+			privateRefresherEnabled: -1,
+			privateShowRefresherWhenReload: false,
+			customRefresherHeight: -1,
+			showCustomRefresher: false,
+			doRefreshAnimateAfter: false,
+			isRefresherInComplete: false,
+			pullDownTimeStamp: 0,
+			moveDis: 0,
+			oldMoveDis: 0,
+			oldRefresherTouchmoveY: 0,
+			oldTouchDirection: ''
+		}
+	},
+	watch: {
+		refresherDefaultStyle: {
+			handler(newVal) {
+				if (newVal.length) {
+					this.finalRefresherDefaultStyle = newVal;
+				}
+			},
+			immediate: true
+		},
+		refresherStatus(newVal, oldVal) {
+			if (newVal === Enum.Refresher.Loading){
+				this._cleanRefresherEndTimeout();
+			}
+			this.$emit('refresherStatusChange', newVal);
+			this.$emit('update:refresherStatus', newVal);
+		},
+		moveDis(newVal, oldVal){
+			this.oldMoveDis = oldVal;
+		}
+	},
+	computed: {
+		pullDownDisTimeStamp() {
+			return 1000 / this.refresherFps;
+		},
+		finalRefresherEnabled() {
+			if (this.useChatRecordMode) return false;
+			if (this.privateRefresherEnabled === -1) return this.refresherEnabled;
+			return this.privateRefresherEnabled === 1;
+		},
+		finalRefresherThreshold() {
+			let refresherThreshold = this.refresherThreshold;
+			let idDefault = false;
+			if (refresherThreshold === '80rpx') {
+				idDefault = true;
+				if (this.showRefresherUpdateTime) {
+					refresherThreshold = '120rpx';
+				}
+			}
+			if (idDefault && this.customRefresherHeight > 0) {
+				return this.customRefresherHeight;
+			}
+			return u.convertTextToPx(refresherThreshold);
+		},
+		finalRefresherFixedBacHeight() {
+			return u.convertTextToPx(this.refresherFixedBacHeight);
+		},
+		finalRefresherThemeStyle() {
+			return this.refresherThemeStyle.length ? this.refresherThemeStyle : this.defaultThemeStyle;
+		},
+		finalRefresherOutRate() {
+			let rate = this.refresherOutRate;
+			rate = Math.max(0,rate);
+			rate = Math.min(1,rate);
+			return rate;
+		},
+		finalRefresherTransform() {
+			if (this.refresherTransform === 'translateY(0px)') return 'none';
+			return this.refresherTransform;
+		},
+		finalShowRefresherWhenReload() {
+			return this.showRefresherWhenReload || this.privateShowRefresherWhenReload;
+		},
+		finalRefresherTriggered() {
+			if (!(this.finalRefresherEnabled && !this.useCustomRefresher)) return false;
+			return this.refresherTriggered;
+		},
+		showRefresher() {
+			const showRefresher = this.finalRefresherEnabled && this.useCustomRefresher && this.isTouchmoving;
+			// #ifndef APP-NVUE
+			if (this.customRefresherHeight === -1 && showRefresher) {
+				setTimeout(() => {
+					this.$nextTick(()=>{
+						this._updateCustomRefresherHeight();
+					})
+				}, 100)
+			}
+			// #endif
+			return showRefresher;
+		},
+		hasTouchmove(){
+			// #ifdef VUE2
+			// #ifdef APP-VUE || H5
+			if (this.$listeners && !this.$listeners.refresherTouchmove) return false;
+			// #endif
+			// #ifdef MP-WEIXIN || MP-QQ
+			return this.watchRefresherTouchmove;
+			// #endif
+			return true;
+			// #endif
+			return this.watchRefresherTouchmove;
+		},
+	},
+	methods: {
+		//终止下拉刷新状态
+		endRefresh(){
+		   this._refresherEnd();
+		},
+		handleRefresherStatusChanged(func) {
+			this.refresherStatusChangedFunc = func;
+		},
+		//自定义下拉刷新被触发
+		_onRefresh(fromScrollView=false,isUserPullDown=true) {
+			if (fromScrollView && !(this.finalRefresherEnabled && !this.useCustomRefresher)) return;
+			this.$emit('onRefresh');
+			this.$emit('Refresh');
+			// #ifdef APP-NVUE
+			if (this.loading) {
+				setTimeout(()=>{
+					this._nRefresherEnd();
+				},500)
+				return;
+			}
+			// #endif
+			if (this.loading || this.isRefresherInComplete) return;
+			this.loadingType = Enum.LoadingType.Refresher;
+			if (this.nShowRefresherReveal) return;
+			this.isUserPullDown = isUserPullDown;
+			this.isUserReload = !isUserPullDown;
+			this._startLoading(true);
+			this.refresherTriggered = true;
+			if(this.reloadWhenRefresh && isUserPullDown){
+				if (this.useChatRecordMode) {
+					this._onLoadingMore('click')
+				} else {
+					this._reload(false, false, isUserPullDown);
+				}
+			}
+		},
+		//自定义下拉刷新被复位
+		_onRestore() {
+			this.refresherTriggered = 'restore';
+			this.$emit('onRestore');
+			this.$emit('Restore');
+		},
+		// #ifndef APP-VUE || MP-WEIXIN || MP-QQ || H5
+		//拖拽开始
+		_refresherTouchstart(e) {
+			if (this._touchDisabled()) return;
+			const touch = u.getTouch(e);
+			this._handleRefresherTouchstart(touch);
+		},
+		// #endif
+		//进一步处理拖拽开始结果
+		_handleRefresherTouchstart(touch) {
+			if (!this.loading && this.isTouchEnded) {
+				this.isTouchmoving = false;
+			}
+			this.isTouchmovingTimeout && clearTimeout(this.isTouchmovingTimeout);
+			this.isTouchEnded = false;
+			this.refresherTransition = '';
+			this.refresherTouchstartY = touch.touchY;
+			this.$emit('refresherTouchstart', this.refresherTouchstartY);
+			this.lastRefresherTouchmove = touch;
+			this._cleanRefresherCompleteTimeout();
+			this._cleanRefresherEndTimeout();
+		},
+		// #ifndef APP-VUE || MP-WEIXIN || MP-QQ || H5
+		//拖拽中
+		_refresherTouchmove(e) {
+			const currentTimeStamp = u.getTime();
+			let touch = null;
+			let refresherTouchmoveY = 0;
+			if (this.watchTouchDirectionChange) {
+				touch = u.getTouch(e);
+				refresherTouchmoveY = touch.touchY;
+				const direction  = refresherTouchmoveY > this.oldRefresherTouchmoveY ? 'top' : 'bottom';
+				direction === this.oldTouchDirection && this._handleTouchDirectionChange({direction});
+				this.oldTouchDirection = direction;
+				this.oldRefresherTouchmoveY = refresherTouchmoveY;
+			}
+			if (this.pullDownTimeStamp && currentTimeStamp - this.pullDownTimeStamp <= this.pullDownDisTimeStamp) return;
+			if (this._touchDisabled()) return;
+			this.pullDownTimeStamp = Number(currentTimeStamp);
+			touch = u.getTouch(e);
+			refresherTouchmoveY = touch.touchY;
+			let moveDis = refresherTouchmoveY - this.refresherTouchstartY;
+			if (moveDis < 0) return;
+			if (this.refresherMaxAngle >= 0 && this.refresherMaxAngle <= 90 && this.lastRefresherTouchmove && this.lastRefresherTouchmove.touchY <= refresherTouchmoveY) {
+				if (!moveDis && !this.refresherAngleEnableChangeContinued && this.moveDis < 1 && !this.refresherReachMaxAngle) return;
+				const x = Math.abs(touch.touchX - this.lastRefresherTouchmove.touchX);
+				const y = Math.abs(refresherTouchmoveY - this.lastRefresherTouchmove.touchY);
+				const z = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
+				if ((x || y) && x > 1) {
+					const angle = Math.asin(y / z) / Math.PI * 180;
+					if (angle < this.refresherMaxAngle) {
+						this.lastRefresherTouchmove = touch;
+						this.refresherReachMaxAngle = false;
+						return;
+					}
+				}
+			}
+			moveDis = this._getFinalRefresherMoveDis(moveDis);
+			this._handleRefresherTouchmove(moveDis, touch);
+			if (!this.disabledBounce) {
+				if(this.isIos){
+					// #ifndef MP-LARK
+					this._handleScrollViewDisableBounce({bounce: false});
+					// #endif
+				}
+				this.disabledBounce = true;
+			}
+			this._emitTouchmove({pullingDistance:moveDis,dy:this.moveDis - this.oldMoveDis});
+		},
+		// #endif
+		//进一步处理拖拽中结果
+		_handleRefresherTouchmove(moveDis, touch) {
+			this.refresherReachMaxAngle = true;
+			this.isTouchmovingTimeout && clearTimeout(this.isTouchmovingTimeout);
+			this.isTouchmoving = true;
+			//this.refresherTransition = '';
+			this.isTouchEnded = false;
+			this.refresherStatus = moveDis >= this.finalRefresherThreshold ? Enum.Refresher.ReleaseToRefresh : this.refresherStatus = Enum.Refresher.Default;
+			// #ifndef APP-VUE || MP-WEIXIN || MP-QQ  || H5
+			// this.scrollEnable = false;
+			this.refresherTransform = `translateY(${moveDis}px)`;
+			this.lastRefresherTouchmove = touch;
+			// #endif
+			this.moveDis = moveDis;
+		},
+		// #ifndef APP-VUE || MP-WEIXIN || MP-QQ || H5
+		//拖拽结束
+		_refresherTouchend(e) {
+			if (this._touchDisabled() || !this.isTouchmoving) return;
+			const touch = u.getTouch(e);
+			let refresherTouchendY = touch.touchY;
+			let moveDis = refresherTouchendY - this.refresherTouchstartY;
+			moveDis = this._getFinalRefresherMoveDis(moveDis);
+			this._handleRefresherTouchend(moveDis);
+			this._handleScrollViewDisableBounce({bounce: true});
+			this.disabledBounce = false;
+		},
+		// #endif
+		//进一步处理拖拽结束结果
+		_handleRefresherTouchend(moveDis) {
+			// #ifndef APP-PLUS || H5 || MP-WEIXIN
+			if (!this.isTouchmoving) return;
+			// #endif
+			this.isTouchmovingTimeout && clearTimeout(this.isTouchmovingTimeout);
+			this.refresherReachMaxAngle = true;
+			if (moveDis < 0 && this.usePageScroll && this.loadingMoreEnabled && this.useCustomRefresher && this.pageScrollTop === -1) {
+				if (this.showConsoleError) {
+					u.consoleErr('usePageScroll为true并且自定义下拉刷新时必须引入mixin或在page滚动时通过调用z-paging组件的updatePageScrollTop方法设置当前的scrollTop');
+				}
+			}
+			this.isTouchEnded = true;
+			if (moveDis >= this.finalRefresherThreshold && this.refresherStatus === Enum.Refresher.ReleaseToRefresh) {
+				// #ifndef APP-VUE || MP-WEIXIN || MP-QQ  || H5
+				this.refresherTransform = `translateY(${this.finalRefresherThreshold}px)`;
+				// #endif
+				this.moveDis = this.finalRefresherThreshold;
+				this.refresherStatus = Enum.Refresher.Loading;
+				this._doRefresherLoad();
+			} else {
+				this._refresherEnd();
+				this.isTouchmovingTimeout = setTimeout(() => {
+					this.isTouchmoving = false;
+				}, this.refresherDefaultDuration);
+			}
+			this.scrollEnable = true;
+			this.$emit('refresherTouchend', moveDis);
+		},
+		//处理scroll-view bounce是否生效
+		_handleScrollViewDisableBounce(e) {
+			if (!this.usePageScroll && !this.scrollToTopBounceEnabled) {
+				this.refresherTransition = '';
+				this.scrollEnable = e.bounce;
+			}
+		},
+		//wxs正在下拉状态改变处理
+		_handleWxsPullingDownStatusChange(onPullingDown) {
+			this.wxsOnPullingDown = onPullingDown;
+			if (onPullingDown && !this.useChatRecordMode) {
+				this.renderPropScrollTop = 0;
+			}
+		},
+		//wxs正在下拉处理
+		_handleWxsPullingDown(e){
+			this._emitTouchmove({pullingDistance:e.moveDis,dy:e.diffDis});
+		},
+		//wxs触摸方向改变
+		_handleTouchDirectionChange(e) {
+			this.$emit('touchDirectionChange',e.direction);
+		},
+		//wxs通知更新其props
+		_handlePropUpdate(e){
+			this.wxsPropType = u.getTime().toString();
+		},
+		//下拉刷新结束
+		_refresherEnd(shouldEndLoadingDelay = true, fromAddData = false, isUserPullDown = false, setLoading = true) {
+			if (this.loadingType === Enum.LoadingType.Refresher) {
+				let refresherCompleteDelay = 0;
+				if(fromAddData && (isUserPullDown || this.showRefresherWhenReload)){
+					refresherCompleteDelay = this.refresherCompleteDuration > 700 ? 1 : this.refresherCompleteDelay;
+				}
+				const refresherStatus = refresherCompleteDelay > 0 ? Enum.Refresher.Complete : Enum.Refresher.Default;
+				if (this.finalShowRefresherWhenReload) {
+					const stackCount = this.refresherRevealStackCount;
+					this.refresherRevealStackCount--;
+					if (stackCount > 1) return;
+				}
+				this._cleanRefresherEndTimeout();
+				this.refresherEndTimeout = setTimeout(() => {
+					this.refresherStatus = refresherStatus;
+				}, this.refresherStatus !== Enum.Refresher.Default && refresherStatus === Enum.Refresher.Default ? this.refresherCompleteDuration : 0);
+				
+				// #ifndef APP-NVUE
+				if (refresherCompleteDelay > 0) {
+					this.isRefresherInComplete = true;
+				}
+				// #endif
+				this._cleanRefresherCompleteTimeout();
+				this.refresherCompleteTimeout = setTimeout(() => {
+					let animateDuration = 1;
+					const animateType = this.refresherEndBounceEnabled && fromAddData ? 'cubic-bezier(0.19,1.64,0.42,0.72)' : 'linear';
+					if (fromAddData) {
+						animateDuration = this.refresherEndBounceEnabled ? this.refresherCompleteDuration / 1000 : this.refresherCompleteDuration / 3000;
+					}
+					this.refresherTransition = `transform ${fromAddData ? animateDuration : this.refresherDefaultDuration / 1000}s ${animateType}`;
+					// #ifndef APP-VUE || MP-WEIXIN || MP-QQ  || H5
+					this.refresherTransform = 'translateY(0px)';
+					// #endif
+					// #ifdef APP-VUE || MP-WEIXIN || MP-QQ || H5
+					this.wxsPropType = this.refresherTransition + 'end' + u.getTime();
+					// #endif
+					// #ifdef APP-NVUE
+					this._nRefresherEnd();
+					// #endif
+					this.moveDis = 0;
+					// #ifndef APP-NVUE
+					if (refresherStatus === Enum.Refresher.Complete) {
+						if (this.refresherCompleteSubTimeout) {
+							clearTimeout(this.refresherCompleteSubTimeout);
+							this.refresherCompleteSubTimeout = null;
+						}
+						this.refresherCompleteSubTimeout = setTimeout(() => {
+							this.$nextTick(() => {
+								this.refresherStatus = Enum.Refresher.Default;
+								this.isRefresherInComplete = false;
+							})
+						}, animateDuration * 800);
+					}
+					// #endif
+				}, refresherCompleteDelay);
+			}
+			if (setLoading) {
+				setTimeout(() => {
+					this.loading = false;
+				}, shouldEndLoadingDelay ? c.delayTime : 0);
+				isUserPullDown && this._onRestore();
+			}
+		},
+		//模拟用户手动触发下拉刷新
+		_doRefresherRefreshAnimate() {
+			this._cleanRefresherCompleteTimeout();
+			// #ifndef APP-NVUE
+			const doRefreshAnimateAfter = !this.doRefreshAnimateAfter && (this.finalShowRefresherWhenReload) && this
+				.customRefresherHeight === -1 && this.refresherThreshold === '80rpx';
+			if (doRefreshAnimateAfter) {
+				this.doRefreshAnimateAfter = true;
+				return;
+			}
+			// #endif
+			this.refresherRevealStackCount++;
+			// #ifndef APP-VUE || MP-WEIXIN || MP-QQ  || H5
+			this.refresherTransform = `translateY(${this.finalRefresherThreshold}px)`;
+			// #endif
+			// #ifdef APP-VUE || MP-WEIXIN || MP-QQ || H5
+			this.wxsPropType = 'begin' + u.getTime();
+			// #endif
+			this.moveDis = this.finalRefresherThreshold;
+			this.refresherStatus = Enum.Refresher.Loading;
+			this.isTouchmoving = true;
+			this.isTouchmovingTimeout && clearTimeout(this.isTouchmovingTimeout);
+			this._doRefresherLoad(false);
+		},
+		//触发下拉刷新
+		_doRefresherLoad(isUserPullDown=true) {
+			this._onRefresh(false,isUserPullDown);
+			this.loading = true;
+		},
+		//获取处理后的moveDis
+		_getFinalRefresherMoveDis(moveDis) {
+			moveDis = moveDis * 0.85;
+			if (moveDis >= this.finalRefresherThreshold) {
+				moveDis = this.finalRefresherThreshold + (moveDis - this.finalRefresherThreshold) * (1 - this.finalRefresherOutRate);
+			}
+			return moveDis;
+		},
+		// #ifndef APP-VUE || MP-WEIXIN || MP-QQ || H5
+		//判断touch手势是否要触发
+		_touchDisabled() {
+			let checkOldScrollTop = this.oldScrollTop > 5;
+			return this.loading || this.isRefresherInComplete || this.useChatRecordMode || !this.refresherEnabled || !this.useCustomRefresher ||(this.usePageScroll && this.useCustomRefresher && this.pageScrollTop > 10) || (!(this.usePageScroll && this.useCustomRefresher) && checkOldScrollTop);
+		},
+		// #endif
+		//更新自定义下拉刷新view高度
+		_updateCustomRefresherHeight() {
+			this._getNodeClientRect('.zp-custom-refresher-slot-view').then((res) => {
+				if (res) {
+					this.customRefresherHeight = res[0].height;
+					if (this.customRefresherHeight > 0) {
+						this.showCustomRefresher = true;
+					}
+				} else {
+					this.customRefresherHeight = 0;
+				}
+				if (this.doRefreshAnimateAfter) {
+					this.doRefreshAnimateAfter = false;
+					this._doRefresherRefreshAnimate();
+				}
+			});
+		},
+		//发射pullingDown事件
+		_emitTouchmove(e){
+			// #ifndef APP-NVUE
+			e.viewHeight = this.finalRefresherThreshold;
+			// #endif
+			e.rate = e.pullingDistance / e.viewHeight;
+			if(this.hasTouchmove){
+				this.$emit('refresherTouchmove',e);
+			}
+		},
+		//清除refresherCompleteTimeout
+		_cleanRefresherCompleteTimeout() {
+			this.refresherCompleteTimeout = this._cleanTimeout(this.refresherCompleteTimeout);
+			// #ifdef APP-NVUE
+			this._nRefresherEnd(false);
+			// #endif
+		},
+		//清除refresherEndTimeout
+		_cleanRefresherEndTimeout() {
+			this.refresherEndTimeout = this._cleanTimeout(this.refresherEndTimeout);
+		},
+	}
+}
+
+export default ZPRefresher;

components/z-paging/js/modules/scroller.js

@@ -0,0 +1,469 @@
+// [z-paging]scroll相关模块
+import u from '.././z-paging-utils'
+import Enum from '.././z-paging-enum'
+
+// #ifdef APP-NVUE
+const weexDom = weex.requireModule('dom');
+// #endif
+const ZPScroller = {
+	props: {
+		//使用页面滚动，默认为否，当设置为是时则使用页面的滚动而非此组件内部的scroll-view的滚动，使用页面滚动时z-paging无需设置确定的高度且对于长列表展示性能更高，但配置会略微繁琐
+		usePageScroll: {
+			type: Boolean,
+			default: u.gc('usePageScroll', false)
+		},
+		//是否可以滚动，使用内置scroll-view和nvue时有效，默认为是
+		scrollable: {
+			type: Boolean,
+			default: u.gc('scrollable', true)
+		},
+		//控制是否出现滚动条，默认为是
+		showScrollbar: {
+			type: Boolean,
+			default: u.gc('showScrollbar', true)
+		},
+		//是否允许横向滚动，默认为否
+		scrollX: {
+			type: Boolean,
+			default: u.gc('scrollX', false)
+		},
+		//iOS设备上滚动到顶部时是否允许回弹效果，默认为否。关闭回弹效果后可使滚动到顶部与下拉刷新更连贯，但是有吸顶view时滚动到顶部时可能出现抖动。
+		scrollToTopBounceEnabled: {
+			type: Boolean,
+			default: u.gc('scrollToTopBounceEnabled', false)
+		},
+		//iOS设备上滚动到底部时是否允许回弹效果，默认为是。
+		scrollToBottomBounceEnabled: {
+			type: Boolean,
+			default: u.gc('scrollToBottomBounceEnabled', true)
+		},
+		//在设置滚动条位置时使用动画过渡，默认为否
+		scrollWithAnimation: {
+			type: Boolean,
+			default: u.gc('scrollWithAnimation', false)
+		},
+		//值应为某子元素id（id不能以数字开头）。设置哪个方向可滚动，则在哪个方向滚动到该元素
+		scrollIntoView: {
+			type: String,
+			default: u.gc('scrollIntoView', '')
+		},
+	},
+	data() {
+		return {
+			scrollTop: 0,
+			oldScrollTop: 0,
+			scrollViewStyle: {},
+			scrollViewContainerStyle: {},
+			scrollViewInStyle: {},
+			pageScrollTop: -1,
+			scrollEnable: true,
+			privateScrollWithAnimation: -1,
+			cacheScrollNodeHeight: -1
+		}
+	},
+	watch: {
+		oldScrollTop(newVal, oldVal) {
+			!this.usePageScroll && this._scrollTopChange(newVal,oldVal,false);
+		},
+		pageScrollTop(newVal, oldVal) {
+			this.usePageScroll && this._scrollTopChange(newVal,oldVal,true);
+		},
+		usePageScroll: {
+			handler(newVal) {
+				this.$nextTick(() => {
+					this.renderPropUsePageScroll = newVal;
+				})
+				if (this.loaded && this.autoHeight) {
+					this._setAutoHeight(!newVal);
+				}
+				// #ifdef H5
+				if (newVal) {
+					this.$nextTick(()=>{
+						const mainScrollRef = this.$refs['zp-scroll-view'].$refs.main;
+						if (mainScrollRef) {
+							mainScrollRef.style = {};
+						}
+					})
+				}
+				// #endif
+			},
+			immediate: true
+		},
+		finalScrollTop(newVal, oldVal) {
+			if (!this.useChatRecordMode) {
+				this.renderPropScrollTop = newVal < 6 ? 0 : 10;
+			}
+		},
+	},
+	computed: {
+		finalScrollWithAnimation() {
+			if (this.privateScrollWithAnimation !== -1) {
+				const scrollWithAnimation = this.privateScrollWithAnimation === 1;
+				this.privateScrollWithAnimation = -1;
+				return scrollWithAnimation;
+			}
+			return this.scrollWithAnimation;
+		},
+		finalScrollViewStyle() {
+			if (this.superContentZIndex != 1) {
+				this.scrollViewStyle['z-index'] = this.superContentZIndex;
+				this.scrollViewStyle['position'] = 'relative';
+			}
+			return this.scrollViewStyle;
+		},
+		finalScrollTop() {
+			return this.usePageScroll ? this.pageScrollTop : this.oldScrollTop;
+		},
+		finalIsOldWebView() {
+			return this.isOldWebView && !this.usePageScroll;
+		}
+	},
+	methods: {
+		//滚动到顶部，animate为是否展示滚动动画，默认为是
+		scrollToTop(animate,checkReverse = true) {
+			// #ifdef APP-NVUE
+			if (checkReverse && this.useChatRecordMode) {
+				if(!this.nIsFirstPageAndNoMore){
+					this.scrollToBottom(animate, false);
+					return;
+				}
+			}
+			// #endif
+			this.$nextTick(() => {
+				this._scrollToTop(animate, false);
+				// #ifdef APP-NVUE
+				if (this.nvueFastScroll && animate) {
+					setTimeout(() => {
+						this._scrollToTop(false, false);
+					}, 150);
+				}
+				// #endif
+			})
+		},
+		//滚动到底部，animate为是否展示滚动动画，默认为是
+		scrollToBottom(animate,checkReverse = true) {
+			// #ifdef APP-NVUE
+			if (checkReverse && this.useChatRecordMode) {
+				if(!this.nIsFirstPageAndNoMore){
+					this.scrollToTop(animate, false);
+					return;
+				}
+			}
+			// #endif
+			this.$nextTick(() => {
+				this._scrollToBottom(animate);
+				// #ifdef APP-NVUE
+				if (this.nvueFastScroll && animate) {
+					setTimeout(() => {
+						this._scrollToBottom(false);
+					}, 150);
+				}
+				// #endif
+			})
+		},
+		//滚动到指定view(vue中有效)。sel为需要滚动的view的id值，不包含"#"；offset为偏移量，单位为px；animate为是否展示滚动动画，默认为否
+		scrollIntoViewById(sel, offset, animate) {
+			this._scrollIntoView(sel, offset, animate);
+		},
+		//滚动到指定view(vue中有效)。nodeTop为需要滚动的view的top值(通过uni.createSelectorQuery()获取)；offset为偏移量，单位为px；animate为是否展示滚动动画，默认为否
+		scrollIntoViewByNodeTop(nodeTop, offset, animate) {
+			this.scrollTop = this.oldScrollTop;
+			this.$nextTick(() => {
+				this._scrollIntoViewByNodeTop(nodeTop, offset, animate);
+			})
+		},
+		//滚动到指定位置(vue中有效)。y为与顶部的距离，单位为px；offset为偏移量，单位为px；animate为是否展示滚动动画，默认为否
+		scrollToY(y, offset, animate) {
+			this.scrollTop = this.oldScrollTop;
+			this.$nextTick(() => {
+				this._scrollToY(y, offset, animate);
+			})
+		},
+		//滚动到指定view(nvue中有效)。index为需要滚动的view的index(第几个)；offset为偏移量，单位为px；animate为是否展示滚动动画，默认为否
+		scrollIntoViewByIndex(index, offset, animate) {
+			this._scrollIntoView(index, offset, animate);
+		},
+		//滚动到指定view(nvue中有效)。view为需要滚动的view(通过`this.$refs.xxx`获取)，不包含"#"；offset为偏移量，单位为px；animate为是否展示滚动动画，默认为否
+		scrollIntoViewByView(view, offset, animate) {
+			this._scrollIntoView(view, offset, animate);
+		},
+		//当使用页面滚动并且自定义下拉刷新时，请在页面的onPageScroll中调用此方法，告知z-paging当前的pageScrollTop，否则会导致在任意位置都可以下拉刷新
+		updatePageScrollTop(value) {
+			if (value == undefined) {
+				u.consoleErr('updatePageScrollTop方法缺少参数，请将页面onPageScroll事件中的scrollTop传递给此方法');
+				return;
+			}
+			this.pageScrollTop = value;
+		},
+		//当使用页面滚动并且设置了slot="top"时，默认初次加载会自动获取其高度，并使内部容器下移，当slot="top"的view高度动态改变时，在其高度需要更新时调用此方法
+		updatePageScrollTopHeight() {
+			this._updatePageScrollTopOrBottomHeight('top');
+		},
+		//当使用页面滚动并且设置了slot="bottom"时，默认初次加载会自动获取其高度，并使内部容器下移，当slot="bottom"的view高度动态改变时，在其高度需要更新时调用此方法
+		updatePageScrollBottomHeight() {
+			this._updatePageScrollTopOrBottomHeight('bottom');
+		},
+		//更新z-paging内置scroll-view的scrollTop
+		updateScrollViewScrollTop(scrollTop, animate = true) {
+			this.privateScrollWithAnimation = animate ? 1 : 0;
+			this.scrollTop = this.oldScrollTop;
+			this.$nextTick(() => {
+				this.scrollTop = scrollTop;
+				this.oldScrollTop = this.scrollTop;
+			});
+		},
+		
+		//当滚动到顶部时
+		_scrollToUpper() {
+			this.$emit('scrolltoupper');
+			this.$emit('scrollTopChange', 0);
+			this.$nextTick(() => {
+				this.oldScrollTop = 0;
+			})
+			if (!this.useChatRecordMode) return;
+			if (this.loadingStatus === Enum.More.NoMore) return;
+			this._onLoadingMore('click');
+		},
+		//滚动到顶部
+		_scrollToTop(animate = true, isPrivate = true) {
+			// #ifdef APP-NVUE
+			const el = this.$refs['zp-n-list-top-tag'];
+			if (this.usePageScroll) {
+				this._getNodeClientRect('zp-page-scroll-top', false).then((node) => {
+					let nodeHeight = 0;
+					if (node) {
+						nodeHeight = node[0].height;
+					}
+					weexDom.scrollToElement(el, {
+						offset: -nodeHeight,
+						animated: animate
+					});
+				});
+			} else {
+				if(!this.isIos && this.nvueListIs === 'scroller'){
+					this._getNodeClientRect('zp-n-refresh-container', false).then((node) => {
+						let nodeHeight = 0;
+						if (node) {
+							nodeHeight = node[0].height;
+						}
+						weexDom.scrollToElement(el, {
+							offset: -nodeHeight,
+							animated: animate
+						});
+					});
+				}else{
+					weexDom.scrollToElement(el, {
+						offset: 0,
+						animated: animate
+					});
+				}
+			}
+			return;
+			// #endif
+			if (this.usePageScroll) {
+				this.$nextTick(() => {
+					uni.pageScrollTo({
+						scrollTop: 0,
+						duration: animate ? 100 : 0,
+					});
+				});
+				return;
+			}
+			this.privateScrollWithAnimation = animate ? 1 : 0;
+			this.scrollTop = this.oldScrollTop;
+			this.$nextTick(() => {
+				this.scrollTop = 0;
+				this.oldScrollTop = this.scrollTop;
+			});
+		},
+		//滚动到底部
+		async _scrollToBottom(animate = true) {
+			// #ifdef APP-NVUE
+			const el = this.$refs['zp-n-list-bottom-tag'];
+			if (el) {
+				weexDom.scrollToElement(el, {
+					offset: 0,
+					animated: animate
+				});
+			} else {
+				u.consoleErr('滚动到底部失败，因为您设置了hideNvueBottomTag为true');
+			}
+			return;
+			// #endif
+			if (this.usePageScroll) {
+				this.$nextTick(() => {
+					uni.pageScrollTo({
+						scrollTop: Number.MAX_VALUE,
+						duration: animate ? 100 : 0,
+					});
+				});
+				return;
+			}
+			try {
+				this.privateScrollWithAnimation = animate ? 1 : 0;
+				let pagingContainerH = 0;
+				let scrollViewH = 0;
+				const pagingContainerNode = await this._getNodeClientRect('.zp-paging-container');
+				const scrollViewNode = await this._getNodeClientRect('.zp-scroll-view');
+				if (pagingContainerNode) {
+					pagingContainerH = pagingContainerNode[0].height;
+				}
+				if (scrollViewNode) {
+					scrollViewH = scrollViewNode[0].height;
+				}
+				if (pagingContainerH > scrollViewH) {
+					this.scrollTop = this.oldScrollTop;
+					this.$nextTick(() => {
+						this.scrollTop = pagingContainerH - scrollViewH + this.virtualPlaceholderTopHeight;
+						this.oldScrollTop = this.scrollTop;
+					});
+				}
+			} catch (e) {}
+		},
+		//滚动到指定view
+		_scrollIntoView(sel, offset = 0, animate = false, finishCallback) {
+			try {
+				this.scrollTop = this.oldScrollTop;
+				this.$nextTick(() => {
+					// #ifdef APP-NVUE
+					const refs = this.$parent.$refs;
+					if (!refs) return;
+					const dataType = Object.prototype.toString.call(sel);
+					let el = null;
+					if (dataType === '[object Number]') {
+						const els = refs[`z-paging-${sel}`];
+						el = els ? els[0] : null;
+					} else if (dataType === '[object Array]') {
+						el = sel[0];
+					} else {
+						el = sel;
+					}
+					if (el) {
+						weexDom.scrollToElement(el, {
+							offset: -offset,
+							animated: animate
+						});
+					} else {
+						u.consoleErr('在nvue中滚动到指定位置，cell必须设置 :ref="`z-paging-${index}`"');
+					}
+					return;
+					// #endif
+					if (sel.indexOf('#') != -1) {
+						sel = sel.replace('#', '');
+					}
+					this._getNodeClientRect('#' + sel, false).then((node) => {
+						if (node) {
+							let nodeTop = node[0].top;
+							this._scrollIntoViewByNodeTop(nodeTop, offset, animate);
+							if (finishCallback) {
+								finishCallback();
+							}
+						}
+					});
+				});
+			} catch (e) {}
+		},
+		//通过nodeTop滚动到指定view
+		_scrollIntoViewByNodeTop(nodeTop, offset = 0, animate = false) {
+			this._scrollToY(nodeTop,offset,animate,true);
+		},
+		//滚动到指定位置
+		_scrollToY(y, offset = 0, animate = false, addScrollTop = false) {
+			this.privateScrollWithAnimation = animate ? 1 : 0;
+			if (this.usePageScroll) {
+				uni.pageScrollTo({
+					scrollTop: y - offset,
+					duration: animate ? 100 : 0
+				});
+			} else {
+				if(addScrollTop){
+				   y += this.oldScrollTop; 
+				}
+				this.scrollTop = y - offset;
+				this.oldScrollTop = this.scrollTop;
+			}
+		},
+		//scroll-view滚动中
+		_scroll(e) {
+			this.$emit('scroll', e);
+			const scrollTop = e.detail.scrollTop;
+			// #ifndef APP-NVUE
+			this.finalUseVirtualList && this._updateVirtualScroll(scrollTop,this.oldScrollTop - scrollTop);
+			// #endif
+			this.oldScrollTop = scrollTop;
+			const scrollDiff = e.detail.scrollHeight - this.oldScrollTop;
+			!this.isIos && this._checkScrolledToBottom(scrollDiff);
+		},
+		//scrollTop改变时触发
+		_scrollTopChange(newVal,oldVal,isPageScrollTop){
+			this.$emit('scrollTopChange', newVal);
+			this.$emit('update:scrollTop', newVal);
+			this._checkShouldShowBackToTop(newVal, oldVal);
+			const scrollTop = this.isIos ? (newVal > 5 ? 6 : 0) : newVal;
+			if (isPageScrollTop) {
+				this.wxsPageScrollTop = scrollTop;
+			} else {
+				this.wxsScrollTop = scrollTop;
+			}
+		},
+		//更新使用页面滚动时slot="top"或"bottom"插入view的高度
+		_updatePageScrollTopOrBottomHeight(type) {
+			// #ifndef APP-NVUE
+			if (!this.usePageScroll) return;
+			// #endif
+			this._doCheckScrollViewShouldFullHeight(this.realTotalData);
+			const node = `.zp-page-${type}`;
+			const marginText = `margin${type.slice(0,1).toUpperCase() + type.slice(1)}`;
+			let safeAreaInsetBottomAdd = this.safeAreaInsetBottom;
+			// #ifdef APP-NVUE
+			if (!this.usePageScroll) {
+				safeAreaInsetBottomAdd = false;
+			}
+			// #endif
+			this.$nextTick(() => {
+				let delayTime = 0;
+				// #ifdef MP-BAIDU || APP-NVUE
+				delayTime = 10;
+				// #endif
+				setTimeout(() => {
+					this._getNodeClientRect(node).then((res) => {
+						if (res) {
+							let pageScrollNodeHeight = res[0].height;
+							if (type === 'bottom') {
+								if (safeAreaInsetBottomAdd) {
+									pageScrollNodeHeight += this.safeAreaBottom;
+								}
+							} else {
+								this.cacheTopHeight = pageScrollNodeHeight;
+							}
+							this.$set(this.scrollViewStyle, marginText,
+								`${pageScrollNodeHeight}px`);
+						} else if (safeAreaInsetBottomAdd) {
+							this.$set(this.scrollViewStyle, marginText, `${this.safeAreaBottom}px`);
+						}
+					});
+				}, delayTime)
+			})
+		},
+		//获取slot="left"和slot="right"宽度并且更新布局
+		_updateLeftAndRightWidth(){
+			if (!this.finalIsOldWebView) return;
+			this.$nextTick(() => {
+				let delayTime = 0;
+				// #ifdef MP-BAIDU
+				delayTime = 10;
+				// #endif
+				setTimeout(() => {
+					this._getNodeClientRect('.zp-page-left').then((res) => {
+						this.scrollViewContainerStyle['left'] = res ? res[0].width + 'px' : 0;
+					});
+					this._getNodeClientRect('.zp-page-right').then((res) => {
+						this.scrollViewContainerStyle['right'] = res ? res[0].width + 'px' : 0;
+					});
+				}, delayTime)
+			})
+		}
+	}
+}
+
+export default ZPScroller;

components/z-paging/js/modules/virtual-list.js

@@ -0,0 +1,374 @@
+// [z-paging]虚拟列表模块
+import u from '.././z-paging-utils'
+import c from '.././z-paging-constant'
+import Enum from '.././z-paging-enum'
+
+const ZPVirtualList = {
+	props: {
+		//是否使用虚拟列表，默认为否
+		useVirtualList: {
+			type: Boolean,
+			default: u.gc('useVirtualList', false)
+		},
+		//是否在z-paging内部循环渲染列表(内置列表)，默认为否。若use-virtual-list为true，则此项恒为true
+		useInnerList: {
+			type: Boolean,
+			default: u.gc('useInnerList', false)
+		},
+		//强制关闭inner-list，默认为false，如果为true将强制关闭innerList，适用于开启了虚拟列表后需要强制关闭inner-list的情况
+		forceCloseInnerList: {
+			type: Boolean,
+			default: u.gc('forceCloseInnerList', false)
+		},
+		//内置列表cell的key名称，仅nvue有效，在nvue中开启use-inner-list时必须填此项
+		cellKeyName: {
+			type: String,
+			default: u.gc('cellKeyName', '')
+		},
+		//innerList样式
+		innerListStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('innerListStyle', {});
+			}
+		},
+		//innerCell样式
+		innerCellStyle: {
+			type: Object,
+			default: function() {
+				return u.gc('innerCellStyle', {});
+			}
+		},
+		//预加载的列表可视范围(列表高度)页数，默认为7，即预加载当前页及上下各7页的cell。此数值越大，则虚拟列表中加载的dom越多，内存消耗越大(会维持在一个稳定值)，但增加预加载页面数量可缓解快速滚动短暂白屏问题
+		preloadPage: {
+			type: [Number, String],
+			default: u.gc('preloadPage', 7),
+			validator: (value) => {
+				if (value <= 0) u.consoleErr('preload-page必须大于0！');
+				return value > 0;
+			}
+		},
+		//虚拟列表cell高度模式，默认为fixed，也就是每个cell高度完全相同，将以第一个cell高度为准进行计算。可选值【dynamic】，即代表高度是动态非固定的，【dynamic】性能低于【fixed】。
+		cellHeightMode: {
+			type: String,
+			default: u.gc('cellHeightMode', 'fixed')
+		},
+		//虚拟列表列数，默认为1。常用于每行有多列的情况，例如每行有2列数据，需要将此值设置为2
+		virtualListCol: {
+			type: [Number, String],
+			default: u.gc('virtualListCol', 1)
+		},
+		//虚拟列表scroll取样帧率，默认为60，过高可能出现卡顿等问题
+		virtualScrollFps: {
+			type: [Number, String],
+			default: u.gc('virtualScrollFps', 60)
+		},
+	},
+	data() {
+		return {
+			virtualListKey: u.getInstanceId(),
+			virtualPageHeight: 0,
+			virtualCellHeight: 0,
+			virtualScrollTimeStamp: 0,
+			
+			virtualList: [],
+			virtualPlaceholderTopHeight: 0,
+			virtualPlaceholderBottomHeight: 0,
+			virtualTopRangeIndex: 0,
+			virtualBottomRangeIndex: 0,
+			lastVirtualTopRangeIndex: 0,
+			lastVirtualBottomRangeIndex: 0,
+			
+			virtualHeightCacheList: [],
+			
+			getCellHeightRetryCount: {
+				fixed: 0,
+				dynamic: 0
+			},
+			pagingOrgTop: -1,
+			updateVirtualListFromDataChange: false
+		}
+	},
+	watch: {
+		realTotalData(newVal) {
+			// #ifndef APP-NVUE
+			if (this.finalUseVirtualList) {
+				this.updateVirtualListFromDataChange = true;
+				this.$nextTick(() => {
+					if (!newVal.length) {
+						this._resetDynamicListState(!this.isUserPullDown);
+					}
+					this.getCellHeightRetryCount.fixed = 0;
+					this.finalUseVirtualList && newVal.length && this.cellHeightMode === Enum.CellHeightMode.Fixed && this.isFirstPage && this._updateFixedCellHeight();
+					this.finalUseVirtualList && this._updateVirtualScroll(this.oldScrollTop);
+				})
+			}
+			// #endif
+		},
+		virtualList(newVal){
+			this.$emit('update:virtualList', newVal);
+			this.$emit('virtualListChange', newVal);
+		}
+	},
+	computed: {
+		finalUseVirtualList() {
+			if (this.useVirtualList && this.usePageScroll){
+				u.consoleErr('使用页面滚动时，开启虚拟列表无效！');
+			}
+			return this.useVirtualList && !this.usePageScroll;
+		},
+		finalUseInnerList() {
+			return this.useInnerList || (this.finalUseVirtualList && !this.forceCloseInnerList)
+		},
+		finalCellKeyName() {
+			// #ifdef APP-NVUE
+			if (this.finalUseVirtualList){
+				if (!this.cellKeyName.length){
+					u.consoleErr('在nvue中开启use-virtual-list必须设置cell-key-name，否则将可能导致列表渲染错误！');
+				}
+			}
+			// #endif
+			return this.cellKeyName;
+		},
+		finalVirtualPageHeight(){
+			return this.virtualPageHeight > 0 ? this.virtualPageHeight : this.windowHeight;
+			return virtualPageHeight * this.preloadPage;
+		},
+		virtualRangePageHeight(){
+			return this.finalVirtualPageHeight * this.preloadPage;
+		},
+		virtualScrollDisTimeStamp() {
+			return 1000 / this.virtualScrollFps;
+		},
+	},
+	methods: {
+		//初始化虚拟列表
+		_virtualListInit() {
+			this.$nextTick(() => {
+				setTimeout(() => {
+					this._getNodeClientRect('.zp-scroll-view').then(node => {
+						if (node && node.length) {
+							this.pagingOrgTop = node[0].top;
+							this.virtualPageHeight = node[0].height;
+						}
+					});
+				}, 100);
+			})
+		},
+		//cellHeightMode为fixed时获取第一个cell高度
+		_updateFixedCellHeight() {
+			this.$nextTick(() => {
+				const updateFixedCellHeightTimeout = setTimeout(() => {
+					this._getNodeClientRect(`#zp-${0}`,this.finalUseInnerList).then(cellNode => {
+						const hasCellNode = cellNode && cellNode.length;
+						if (!hasCellNode) {
+							clearTimeout(updateFixedCellHeightTimeout);
+							if (this.getCellHeightRetryCount.fixed > 10) {
+								u.consoleErr('获取虚拟列表cell高度失败，可能是for循环cell处没有写:id="`zp-${item.zp_index}`"，请检查您的代码！')
+								return;
+							}
+							this.getCellHeightRetryCount.fixed++;
+							this._updateFixedCellHeight();
+						} else {
+							this.virtualCellHeight = cellNode[0].height;
+							this._updateVirtualScroll(this.oldScrollTop);
+						}
+					});
+				}, 100);
+			})
+		},
+		//cellHeightMode为dynamic时获取每个cell高度
+		_updateDynamicCellHeight(list) {
+			this.$nextTick(() => {
+				const updateDynamicCellHeightTimeout = setTimeout(async () => {
+					for (let i = 0; i < list.length; i++) {
+						let item = list[i];
+						const cellNode = await this._getNodeClientRect(`#zp-${item[c.listCellIndexKey]}`,this.finalUseInnerList);
+						const hasCellNode = cellNode && cellNode.length;
+						const currentHeight = hasCellNode ? cellNode[0].height : 0;
+						if (!hasCellNode) {
+							clearTimeout(updateDynamicCellHeightTimeout);
+							this.virtualHeightCacheList = this.virtualHeightCacheList.slice(-i);
+							if (this.getCellHeightRetryCount.dynamic > 10) {
+								u.consoleErr('获取虚拟列表cell高度失败，可能是for循环cell处没有写:id="`zp-${item.zp_index}`"，请检查您的代码！')
+								return;
+							}
+							this.getCellHeightRetryCount.dynamic++;
+							this._updateDynamicCellHeight(list);
+							break;
+						}
+						let lastHeightCache = null;
+						if (this.virtualHeightCacheList.length) {
+							lastHeightCache = this.virtualHeightCacheList.slice(-1)[0];
+						}
+						const lastHeight = lastHeightCache ? lastHeightCache.totalHeight : 0;
+						this.virtualHeightCacheList.push({
+							height: currentHeight,
+							lastHeight: lastHeight,
+							totalHeight: lastHeight + currentHeight
+						});
+					}
+					this._updateVirtualScroll(this.oldScrollTop);
+				}, 100)
+			})
+		},
+		//设置cellItem的index
+		_setCellIndex(list, isFirstPage) {
+			let lastItem = null;
+			let lastItemIndex = 0;
+			if (!isFirstPage) {
+				lastItemIndex = this.realTotalData.length;
+				if (this.realTotalData.length) {
+					lastItem = this.realTotalData.slice(-1)[0];
+				}
+				if (lastItem && lastItem[c.listCellIndexKey] !== undefined) {
+					lastItemIndex = lastItem[c.listCellIndexKey] + 1;
+				}
+			} else {			
+				this._resetDynamicListState();
+			}
+			for (let i = 0; i < list.length; i++) {
+				let item = list[i];
+				if (!item || Object.prototype.toString.call(item) !== '[object Object]') {
+					item = {item};
+				}
+				item[c.listCellIndexKey] = lastItemIndex + i;
+				item[c.listCellIndexUniqueKey] = `${this.virtualListKey}-${item[c.listCellIndexKey]}`;
+				list[i] = item;
+			}
+			this.getCellHeightRetryCount.dynamic = 0;
+			this.cellHeightMode === Enum.CellHeightMode.Dynamic && this._updateDynamicCellHeight(list);
+		},
+		//更新scroll滚动
+		_updateVirtualScroll(scrollTop, scrollDiff = 0) {
+			const currentTimeStamp = u.getTime();
+			if (scrollTop === 0) {
+				this._resetTopRange();
+			}
+			if (scrollTop !== 0 && this.virtualScrollTimeStamp && currentTimeStamp - this.virtualScrollTimeStamp <= this.virtualScrollDisTimeStamp) {
+				return;
+			}
+			this.virtualScrollTimeStamp = Number(currentTimeStamp);
+			
+			let scrollIndex = 0;
+			const cellHeightMode = this.cellHeightMode;
+			if (cellHeightMode === Enum.CellHeightMode.Fixed) {
+				scrollIndex = parseInt(scrollTop / this.virtualCellHeight) || 0;
+				this._updateFixedTopRangeIndex(scrollIndex);
+				this._updateFixedBottomRangeIndex(scrollIndex);
+			} else if(cellHeightMode === Enum.CellHeightMode.Dynamic) {
+				const scrollDirection = scrollDiff > 0 ? 'top' : 'bottom';
+				const rangePageHeight = this.virtualRangePageHeight;
+				const topRangePageOffset = scrollTop - rangePageHeight;
+				const bottomRangePageOffset = scrollTop + this.finalVirtualPageHeight + rangePageHeight;
+				
+				let virtualBottomRangeIndex = 0;
+				let virtualPlaceholderBottomHeight = 0;
+				let reachedLimitBottom = false;
+				let lastHeightCache = null;
+				const heightCacheList = this.virtualHeightCacheList;
+				if (heightCacheList.length) {
+					lastHeightCache = heightCacheList.slice(-1)[0];
+				}
+				let startTopRangeIndex = this.virtualTopRangeIndex;
+				if (scrollDirection === 'bottom') {
+					for (let i = startTopRangeIndex; i < heightCacheList.length;i++){
+						const heightCacheItem = heightCacheList[i];
+						if (heightCacheItem && heightCacheItem.totalHeight > topRangePageOffset) {
+							this.virtualTopRangeIndex = i;
+							this.virtualPlaceholderTopHeight = heightCacheItem.lastHeight;
+							break;
+						}
+					}
+				} else {
+					let topRangeMatched = false;
+					for (let i = startTopRangeIndex; i >= 0;i--){
+						const heightCacheItem = heightCacheList[i];
+						if (heightCacheItem && heightCacheItem.totalHeight < topRangePageOffset) {
+							this.virtualTopRangeIndex = i;
+							this.virtualPlaceholderTopHeight = heightCacheItem.lastHeight;
+							topRangeMatched = true;
+							break;
+						}
+					}
+					!topRangeMatched && this._resetTopRange();
+				}
+				for (let i = this.virtualTopRangeIndex; i < heightCacheList.length;i++){
+					const heightCacheItem = heightCacheList[i];
+					if (heightCacheItem && heightCacheItem.totalHeight > bottomRangePageOffset) {
+						virtualBottomRangeIndex = i;
+						virtualPlaceholderBottomHeight = lastHeightCache.totalHeight - heightCacheItem.totalHeight;
+						reachedLimitBottom = true;
+						break;
+					}
+				}
+				if (!reachedLimitBottom || this.virtualBottomRangeIndex === 0) {
+					this.virtualBottomRangeIndex = this.realTotalData.length ? this.realTotalData.length - 1 : this.pageSize;
+					this.virtualPlaceholderBottomHeight = 0;
+				} else {
+					this.virtualBottomRangeIndex = virtualBottomRangeIndex;
+					this.virtualPlaceholderBottomHeight = virtualPlaceholderBottomHeight;
+				}
+				this._updateVirtualList();
+			}
+		},
+		//更新fixedCell模式下topRangeIndex&placeholderTopHeight
+		_updateFixedTopRangeIndex(scrollIndex) {
+			let virtualTopRangeIndex = this.virtualCellHeight === 0 ? 0 : scrollIndex - parseInt(this.finalVirtualPageHeight / this.virtualCellHeight) * this.preloadPage;
+			virtualTopRangeIndex *= this.virtualListCol;
+			virtualTopRangeIndex = Math.max(0, virtualTopRangeIndex);
+			this.virtualTopRangeIndex = virtualTopRangeIndex;
+			this.virtualPlaceholderTopHeight = (virtualTopRangeIndex / this.virtualListCol) * this.virtualCellHeight;
+		},
+		//更新fixedCell模式下bottomRangeIndex&placeholderBottomHeight
+		_updateFixedBottomRangeIndex(scrollIndex) {
+			let virtualBottomRangeIndex = this.virtualCellHeight === 0 ? this.pageSize : scrollIndex + parseInt(this.finalVirtualPageHeight / this.virtualCellHeight) * (this.preloadPage + 1);
+			virtualBottomRangeIndex *= this.virtualListCol;
+			virtualBottomRangeIndex = Math.min(this.realTotalData.length, virtualBottomRangeIndex);
+			this.virtualBottomRangeIndex = virtualBottomRangeIndex;
+			this.virtualPlaceholderBottomHeight = (this.realTotalData.length - virtualBottomRangeIndex) * this.virtualCellHeight / this.virtualListCol;
+			this._updateVirtualList();
+		},
+		//更新virtualList
+		_updateVirtualList() {
+			const shouldUpdateList = this.updateVirtualListFromDataChange || (this.lastVirtualTopRangeIndex !== this.virtualTopRangeIndex || this.lastVirtualBottomRangeIndex !== this.virtualBottomRangeIndex);
+			if (shouldUpdateList) {
+				this.updateVirtualListFromDataChange = false;
+				this.lastVirtualTopRangeIndex =  this.virtualTopRangeIndex;
+				this.lastVirtualBottomRangeIndex =  this.virtualBottomRangeIndex;
+				this.virtualList = this.realTotalData.slice(this.virtualTopRangeIndex, this.virtualBottomRangeIndex + 1);
+			}
+		},
+		//重置动态cell模式下的高度缓存数据、虚拟列表和滚动状态
+		_resetDynamicListState(resetVirtualList = false) {
+			this.virtualHeightCacheList = [];
+			if (resetVirtualList) {
+				this.virtualList = [];
+			}
+			this.virtualTopRangeIndex = 0;
+			this.virtualPlaceholderTopHeight = 0;
+		},
+		//重置topRangeIndex和placeholderTopHeight
+		_resetTopRange() {
+			this.virtualTopRangeIndex = 0;
+			this.virtualPlaceholderTopHeight = 0;
+			this._updateVirtualList();
+		},
+		//检测虚拟列表当前滚动位置，如发现滚动位置不正确则重新计算虚拟列表相关参数(为解决在App中可能出现的长时间进入后台后打开App白屏的问题)
+		_checkVirtualListScroll() {
+			if (this.finalUseVirtualList) {
+				this.$nextTick(() => {
+					this._getNodeClientRect('.zp-paging-touch-view').then(node => {
+						const hasNode = node && node.length;
+						const currentTop = hasNode ? node[0].top : 0;
+						if (!hasNode || (currentTop === this.pagingOrgTop && this.virtualPlaceholderTopHeight !== 0)){
+							this._updateVirtualScroll(0);
+						}
+					});
+				})
+			}
+		}
+	}
+}
+
+export default ZPVirtualList;