uview-plus 3.8.86 → 3.8.108

package/components/u-cell/u-cell.vue

@@ -90,6 +90,11 @@
 			}
 		},
 		mixins: [mpMixin, mixin, props],
+		inject: {
+			uActionSheet: {
+				default: null
+			}
+		},
 		computed: {
 			titleTextStyle() {
 				return addStyle(this.titleStyle)
@@ -123,6 +128,9 @@
 				this.$emit('click', {
 					name: this.name
 				})
+				if (this.stop && typeof this.uActionSheet?.slotClickHandler === 'function') {
+					this.uActionSheet.slotClickHandler()
+				}
 				// 如果配置了url(此props参数通过mixin引入)参数，跳转页面
 				this.openPage()
 				// 是否阻止事件传播

package/components/u-datetime-picker/u-datetime-picker.vue

@@ -108,7 +108,10 @@
                 showByClickInput: false, // 是否在hasInput模式下显示日期选择弹唱
 				columns: [],
 				innerDefaultIndex: [],
-				innerFormatter: (type, value) => value
+				innerFormatter: (type, value) => value,
+				// 记录最近一次通过change上抛给外部的值，用于去重，
+				// 避免边界(min/max)变化导致程序化重建列时再次触发change
+				lastEmitValue: null
 			}
 		},
 		watch: {
@@ -124,6 +127,8 @@
 					this.innerValue = this.correctValue(this.value)
 					// #endif
 					this.updateColumnValue(this.innerValue)
+					// 打开时以外部值为基准，重置去重基准
+					this.lastEmitValue = this.innerValue
 				}
 			},
 			// #ifdef VUE3
@@ -138,14 +143,20 @@
 				// this.getInputValue(newValue)
 			},
 			// #endif
-			propsChange() {
+			// mode变化会改变已选值的语义(时间串<->时间戳)，需要完整重新初始化
+			mode() {
 				this.init()
+			},
+			propsChange() {
+				// 边界(min/max、filter)变化时，保留当前已选值，仅重新校正并重建各列，
+				// 不回退到外部 modelValue，避免未确认前丢失用户已滚动的值
+				this.reInitColumns()
 			}
 		},
 		computed: {
-			// 如果以下这些变量发生了变化，意味着需要重新初始化各列的值
+			// 如果以下这些变量发生了变化，意味着需要重新计算各列范围，但应保留当前已选值
 			propsChange() {
-				return [this.mode, this.maxDate, this.minDate, this.minHour, this.maxHour, this.minMinute, this.maxMinute, this.minSecond, this.maxSecond, this.filter, this.modelValue]
+				return [this.maxDate, this.minDate, this.minHour, this.maxHour, this.minMinute, this.maxMinute, this.minSecond, this.maxSecond, this.filter]
 			},
 			resolvedMaskStyle() {
 				if (this.upHasProp('maskStyle')) {
@@ -249,6 +260,38 @@
 
 				// 初始化hasInput展示
 				this.getInputValue(this.innerValue)
+				// 以外部值为基准，重置去重基准
+				this.lastEmitValue = this.innerValue
+			},
+			// 边界(minMinute等)变化时调用：以当前已选值(innerValue)为基准，
+			// 按新的边界重新校正并重建各列，而不是回退到外部modelValue。
+			// 这样在未点击确认前也不会丢失/重置用户已经滚动选择的值。
+			reInitColumns() {
+				let base = this.innerValue
+				if (base === undefined || base === null || base === '') {
+					// #ifdef VUE3
+					base = this.modelValue
+					// #endif
+					// #ifdef VUE2
+					base = this.value
+					// #endif
+				}
+				// correctValue会把小于新minMinute(或大于maxMinute)的值夹取到合法范围内，
+				// 例如原选中15:30、minMinute变为51时会被夹取为15:51
+				const corrected = this.correctValue(base)
+				const changed = corrected !== this.innerValue
+				this.innerValue = corrected
+				this.updateColumnValue(corrected)
+				this.getInputValue(corrected)
+				// 仅当已选值确实因边界收紧而被夹取变化时，才补发一次change通知外部；
+				// 值未变化则不上抛，避免边界变化引起的重复change
+				if (changed && this.lastEmitValue !== corrected) {
+					this.lastEmitValue = corrected
+					this.$emit('change', {
+						value: corrected,
+						mode: this.mode
+					})
+				}
 			},
 			// 在微信小程序中，不支持将函数当做props参数，故只能通过ref形式调用
 			setFormatter(e) {
@@ -378,8 +421,14 @@
 				}
 				// 取出准确的合法值，防止超越边界的情况
 				selectValue = this.correctValue(selectValue)
+				// 边界变化会程序化重建各列并回填索引，picker-view在部分原生端会再次派发change，
+				// 若此时算出的值与上一次已上抛的值一致，说明并非用户真实操作，直接忽略，避免重复触发change
+				if (selectValue === this.lastEmitValue && selectValue === this.innerValue) {
+					return
+				}
 				this.innerValue = selectValue
 				this.updateColumnValue(selectValue)
+				this.lastEmitValue = selectValue
 				// 发出change时间，value为当前选中的时间戳
 				this.$emit('change', {
 					value: selectValue,

package/components/u-dragsort/u-dragsort.vue

@@ -4,21 +4,21 @@
         :style="movableAreaStyle"
         >
         <movable-area class="u-dragsort-area">
-            <movable-view v-for="(item, index) in list" :key="item.id" :id="`u-dragsort-item-${index}`"
-                class="u-dragsort-item" :class="{ 'dragging': dragIndex === index, disabled: !draggable || item.draggable === false }"
+            <movable-view v-for="(item, index) in list" :key="item.id" :id="`u-dragsort-item-${instanceId}-${item.id}`"
+                class="u-dragsort-item" :class="{ 'dragging': dragItemId === item.id, disabled: !draggable || item.draggable === false }"
                 :direction="direction === 'all' ? 'all' : direction" :x="item.x" :y="item.y" :inertia="false"
-                :disabled="!draggable || dragIndex === -1 || item.draggable === false" @change="onChange(index, $event)"
-                @touchstart="onTouchStart(index, $event)" @touchend="onTouchEnd" @touchcancel="onTouchEnd" @touchmove="onTouchMove">
+                :disabled="!draggable || dragItemId === null || item.draggable === false" @change="onChange(item.id, $event)"
+                @touchstart="onTouchStart(item.id, $event)" @touchend="onTouchEnd" @touchcancel="onTouchEnd" @touchmove="onTouchMove">
                 <view class="u-dragsort-item-content">
                     <view
                         class="ui-dragSort-item-handler"
-                        v-if="$slots.handler"
+                        v-if="hasHandler"
                         data-action="handler"
-                        @touchstart="onTouchStart(index, $event)"
+                        @touchstart="onTouchStart(item.id, $event)"
                     >
-                        <slot name="handler" :item="item" :index="index"></slot>
+                        <slot name="handler" :item="item" :index="getItemIndex(item.id)"></slot>
                     </view>
-                    <slot :item="item" :index="index">
+                    <slot :item="item" :index="getItemIndex(item.id)">
                         {{ item.label }}
                     </slot>
                 </view>
@@ -30,7 +30,7 @@
 <script>
 import { mpMixin } from '../../libs/mixin/mpMixin';
 import { mixin } from '../../libs/mixin/mixin';
-import { sleep } from '../../libs/function/index';
+import { guid, sleep } from '../../libs/function/index';
 export default {
     name: 'u-dragsort',
     // #ifdef MP
@@ -67,7 +67,9 @@ export default {
     data() {
         return {
             list: [],
-            dragIndex: -1,
+            orderIds: [],
+            instanceId: guid(8),
+            dragItemId: null,
             sortChanged: false,
             itemHeight: 0,
             itemWidth: 0,
@@ -99,6 +101,9 @@ export default {
                     width: '100%'
                 }
             }
+        },
+        hasHandler() {
+            return !!(this.$slots.handler || this.$slots.$handler)
         }
     },
     emits: ['drag-end'],
@@ -110,8 +115,17 @@ export default {
     },
     methods: {
         initList() {
+            this.orderIds = this.initialList.map(item => item.id)
+            const currentItems = new Map(this.list.map(item => [item.id, item]))
+            const initialItems = new Map(this.initialList.map(item => [item.id, item]))
+            const renderIds = [
+                ...this.list.map(item => item.id).filter(itemId => initialItems.has(itemId)),
+                ...this.orderIds.filter(itemId => !currentItems.has(itemId))
+            ]
             // 初始化列表项的位置
-            this.list = this.initialList.map((item, index) => {
+            this.list = renderIds.map(itemId => {
+                const item = initialItems.get(itemId)
+                const index = this.getItemIndex(itemId)
                 let x
                 let y
 
@@ -136,6 +150,9 @@ export default {
                 }
             })
         },
+        getItemIndex(itemId) {
+            return this.orderIds.indexOf(itemId)
+        },
         async calculateItemSize() {
             // 计算项目尺寸
             await sleep(30);
@@ -175,12 +192,14 @@ export default {
         },
         updatePositions(isDragging) {
             // 更新所有项目的位置
-            this.list = this.list.map((item, index) => {
+            this.list = this.list.map(item => {
                 // 当前正在拖动的项目保持拖动位置不动，避免抖动
-                if (isDragging && this.dragIndex === index) {
+                if (isDragging && this.dragItemId === item.id) {
                     return item
                 }
 
+                const index = this.getItemIndex(item.id)
+
                 if (this.direction === 'vertical') {
                     return {
                         ...item,
@@ -208,26 +227,31 @@ export default {
                 }
             })
         },
-        onTouchStart(index, e) {
-            if (this.$slots.handler && e.currentTarget.dataset.action !== 'handler') {
+        onTouchStart(itemId, e) {
+            if (this.hasHandler && e.currentTarget.dataset.action !== 'handler') {
                 return
             }
+            const index = this.list.findIndex(item => item.id === itemId)
+            if (index === -1) return
             // 全局禁用或单项禁用时，不进入拖拽态，避免 Android 上小范围漂浮/阴影
             if (!this.draggable || this.list[index]?.draggable === false) return;
             if (this.timer) clearTimeout(this.timer);
             this.sortChanged = false;
-            this.dragIndex = index;
+            this.dragItemId = itemId;
         },
         onTouchMove(e) {
-            if (this.dragIndex !== -1) {
+            if (this.dragItemId !== null) {
                 // 目前只对H5生效, 如果该组件放置在开启了下拉刷新的scroll-view中, 向下拖动item还是会触发下拉刷新
                 e.stopPropagation()
                 e.preventDefault()
             }
         },
-        onChange(index, event) {
+        onChange(itemId, event) {
             if (!event.detail.source || event.detail.source !== 'touch') return;
 
+            const index = this.getItemIndex(itemId)
+            if (index === -1) return;
+
             this.currentPosition.x = event.detail.x;
             this.currentPosition.y = event.detail.y;
 
@@ -274,11 +298,9 @@ export default {
             }
         },
         reorderItems(fromIndex, toIndex) {
-            const movedItem = this.list.splice(fromIndex, 1)[0];
-            this.list.splice(toIndex, 0, movedItem);
+            const movedItemId = this.orderIds.splice(fromIndex, 1)[0];
+            this.orderIds.splice(toIndex, 0, movedItemId);
 
-            // 更新当前拖拽项目的新索引
-            this.dragIndex = toIndex;
             this.sortChanged = true;
 
             // 更新所有项目的位置
@@ -291,25 +313,29 @@ export default {
         },
         onTouchEnd() {
             // 未发生位移
-            if (this.dragIndex === -1) return
+            if (this.dragItemId === null) return
+
+            const dragItem = this.list.find(item => item.id === this.dragItemId)
+            if (!dragItem) return
 
             // 0.001是为了解决拖动过快等某些极限场景下位置还原不生效问题
             if (this.direction === 'horizontal') {
-                this.list[this.dragIndex].x = this.currentPosition.x + 0.001;
+                dragItem.x = this.currentPosition.x + 0.001;
             } else if (this.direction === 'vertical' || this.direction === 'all') {
-                this.list[this.dragIndex].y = this.currentPosition.y + 0.001;
-                this.list[this.dragIndex].x = this.currentPosition.x + 0.001;
+                dragItem.y = this.currentPosition.y + 0.001;
+                dragItem.x = this.currentPosition.x + 0.001;
             }
 
             // 重置到位置，需要延迟触发动，否则无效。
             sleep(50).then(() => {
                 this.updatePositions();
                 if (this.sortChanged) {
-                    this.$emit('drag-end', [...this.list]);
+                    const sortedList = this.orderIds.map(itemId => this.list.find(item => item.id === itemId));
+                    this.$emit('drag-end', sortedList);
                     this.sortChanged = false;
                 }
                 this.timer = setTimeout(() => {
-                    this.dragIndex = -1
+                    this.dragItemId = null
                 }, 600)
             });
         }
@@ -319,6 +345,7 @@ export default {
             handler() {
                 this.$nextTick(() => {
                     this.initList();
+                    this.updatePositions();
                 });
             },
             // deep: true
@@ -372,9 +399,6 @@ export default {
             position: relative;
             padding: 0;
             box-sizing: border-box;
-            border: 1px solid var(--up-border-color, rgba(125, 126, 128, 0.35));
-            border-radius: 8px;
-            background-color: var(--up-card-bg-color, #ffffff);
         }
     }
 

package/components/u-icon/u-icon.vue

@@ -72,10 +72,19 @@
 	export default {
 		name: 'u-icon',
 		beforeCreate() {
-			if (!fontUtil.params.loaded) {
+			// #ifndef APP-VUE
+			if (!fontUtil.isLoaded()) {
 				fontUtil.loadFont();
 			}
+			// #endif
     	},
+		mounted() {
+			// #ifdef APP-VUE
+			if (!fontUtil.isLoaded()) {
+				fontUtil.loadFont();
+			}
+			// #endif
+		},
 		data() {
 			return {
 			}
@@ -161,8 +170,8 @@
 	$u-icon-error: $u-error !default;
 	$u-icon-label-line-height:1 !default;
 
-	/* #ifdef MP-QQ || MP-TOUTIAO || MP-BAIDU || MP-KUAISHOU || MP-XHS */
-	// App端通过uni.loadFontFace加载包内本地字体，避免远程字体阻塞页面渲染。
+	/* #ifdef APP || MP-QQ || MP-TOUTIAO || MP-BAIDU || MP-KUAISHOU || MP-XHS */
+	// 默认保留App端CSS字体，兼容未启用UniUpRoot的老项目；启用UniUpRoot后构建插件会移除App条件并改用本地字体。
 	@font-face {
 		font-family: 'uicon-iconfont';
 		src: url('https://at.alicdn.com/t/font_2225171_8kdcwk4po24.ttf') format('truetype');

package/components/u-icon/util.js

@@ -1,28 +1,74 @@
 import config from '../../libs/config/config';
-// #ifdef APP || APP-NVUE
-import iconFontUrl from './upicon.ttf?url';
-// #endif
 
 const iconFontFamily = 'uicon-iconfont';
+const appIconFontUrl = '_www/static/app-plus/uview-plus/upicon.ttf';
+const useAppStaticIconFont = false;
 
 let params = {
-    loaded: false
+    loaded: false,
+    loading: false
+};
+
+// #ifdef APP-VUE
+const appVueLoadedPages = new WeakSet();
+const appVueLoadingPages = new WeakSet();
+// #endif
+
+const getCurrentAppVuePage = () => {
+    // #ifdef APP-VUE
+    try {
+        if (typeof getCurrentPages !== 'function') return null;
+        const pages = getCurrentPages();
+        if (!Array.isArray(pages) || pages.length === 0) return null;
+        const page = pages[pages.length - 1];
+        return page && (typeof page === 'object' || typeof page === 'function') ? page : null;
+    } catch (e) {
+        return null;
+    }
+    // #endif
+    return null;
+};
+
+const isLoaded = () => {
+    // #ifdef APP-VUE
+    const page = getCurrentAppVuePage();
+    return !!page && appVueLoadedPages.has(page);
+    // #endif
+    return params.loaded;
+};
+
+const getAppIconUrl = () => {
+    // #ifdef APP || APP-NVUE
+    if (!useAppStaticIconFont) {
+        return config.iconUrl;
+    }
+    if (typeof plus !== 'undefined' && plus.io && typeof plus.io.convertLocalFileSystemURL === 'function') {
+        const iconFontPath = plus.io.convertLocalFileSystemURL(appIconFontUrl);
+        if (iconFontPath) return iconFontPath;
+    }
+    return appIconFontUrl;
+    // #endif
+    return '';
 };
 
 const getIconUrl = () => {
     // #ifdef APP || APP-NVUE
-    return iconFontUrl;
+    return getAppIconUrl();
     // #endif
     return config.iconUrl;
 };
 
 const markFontLoaded = () => {
-    // App端使用包内本地字体，重复注册没有收益且会放大多图标页面开销。
-    // #ifdef APP || APP-NVUE
+    // App Vue的字体注册只对当前页面WebView生效，由页面级状态在成功回调中记录。
+    // #ifdef APP-VUE
+    return;
+    // #endif
+    params.loading = false;
+    // #ifdef APP-NVUE
     params.loaded = true;
     return;
     // #endif
-    // 全局加载不稳定，默认关闭，需要开启可以配置loadFontOnce。
+    // 非App Vue平台由loadFontOnce决定成功后是否复用本次加载结果。
     if (config.loadFontOnce) {
         params.loaded = true;
     }
@@ -30,8 +76,20 @@ const markFontLoaded = () => {
 
 // 加载字体方法
 const loadFont = () => {
+    // #ifdef APP-VUE
+    const appVuePage = getCurrentAppVuePage();
+    if (!appVuePage || appVueLoadedPages.has(appVuePage) || appVueLoadingPages.has(appVuePage)) {
+        return false;
+    }
+    appVueLoadingPages.add(appVuePage);
+    // #endif
+    // #ifndef APP-VUE
+    if (params.loaded || params.loading) {
+        return false;
+    }
+    params.loading = true;
+    // #endif
     const iconUrl = getIconUrl();
-    markFontLoaded();
     // #ifdef APP-NVUE
     // nvue通过weex的dom模块引入字体，相关文档地址如下：
     // https://weex.apache.org/zh/docs/modules/dom.html#addrule
@@ -46,16 +104,28 @@ const loadFont = () => {
             'src': `url('${config.customIcon.url}')`
         });
     }
+    markFontLoaded();
     // #endif
-    // #ifdef APP || H5 || MP-WEIXIN || MP-ALIPAY
+    // #ifdef APP-VUE || H5 || MP-WEIXIN || MP-ALIPAY
     uni.loadFontFace({
         global: true, // 是否全局生效。微信小程序 '2.10.0'起支持全局生效，需在 app.vue 中调用。
         family: iconFontFamily,
         source: 'url("' + iconUrl + '")',
         success() {
+            // #ifdef APP-VUE
+            appVueLoadingPages.delete(appVuePage);
+            appVueLoadedPages.add(appVuePage);
+            // #endif
+            markFontLoaded();
             // console.log('内置字体图标加载成功');
         },
         fail() {
+            // #ifdef APP-VUE
+            appVueLoadingPages.delete(appVuePage);
+            // #endif
+            // #ifndef APP-VUE
+            params.loading = false;
+            // #endif
             // console.error('内置字体图标加载出错');
         }
     });
@@ -86,5 +156,6 @@ const loadFont = () => {
 
 export default {
     params: params,
+    isLoaded,
     loadFont
 }

package/components/u-index-item/u-index-item.vue

@@ -20,7 +20,7 @@
 	import { mixin } from '../../libs/mixin/mixin';
 	import { sleep, error } from '../../libs/function/index';
 	// #ifdef APP-NVUE
-	// 由于weex为阿里的KPI业绩考核的产物，所以不支持百分比单位，这里需要通过dom查询组件的宽度
+	// 由于weex不支持百分比单位，这里需要通过dom查询组件的宽度
 	const dom = uni.requireNativePlugin('dom')
 	// #endif
 	/**

package/components/u-index-list/u-index-list.vue

@@ -108,7 +108,7 @@
 	import { addUnit, getWindowInfo, sleep, getPx } from '../../libs/function/index';
 
 	// #ifdef APP-NVUE
-	// 由于weex为阿里的KPI业绩考核的产物，所以不支持百分比单位，这里需要通过dom查询组件的宽度
+	// 由于weex不支持百分比单位，这里需要通过dom查询组件的宽度
 	const dom = uni.requireNativePlugin('dom')
 	// #endif
 	/**

package/components/u-novel-reader/content-normalizer.js

@@ -0,0 +1,80 @@
+const LINE_BREAK_PATTERN = /\r\n|\r|\n/
+
+function normalizeParagraphs(content) {
+    const values = Array.isArray(content) ? content : [content == null ? '' : content]
+    return values.reduce((paragraphs, value) => {
+        String(value == null ? '' : value)
+            .split(LINE_BREAK_PATTERN)
+            .forEach((text) => paragraphs.push(text))
+        return paragraphs
+    }, [])
+}
+
+export function normalizeContent(content) {
+    const sourceParagraphs = normalizeParagraphs(content)
+    const hasContent = sourceParagraphs.some((text) => text.length > 0)
+    if (!hasContent) {
+        return {
+            paragraphs: [],
+            text: '',
+            length: 0
+        }
+    }
+
+    let offset = 0
+    const paragraphs = sourceParagraphs.map((text, index) => {
+        const startOffset = offset
+        const endOffset = startOffset + text.length
+        offset = endOffset + 1
+        return {
+            index,
+            text,
+            startOffset,
+            endOffset
+        }
+    })
+
+    const text = paragraphs.map((paragraph) => paragraph.text).join('\n')
+    return {
+        paragraphs,
+        text,
+        length: text.length
+    }
+}
+
+export function normalizeProgress(progress, chapter) {
+    const normalizedContent = normalizeContent(chapter && chapter.content)
+    const contentLength = normalizedContent.length
+    const requestedOffset = Number(progress && progress.charOffset)
+    const charOffset = Math.min(
+        contentLength,
+        Math.max(0, Number.isFinite(requestedOffset) ? requestedOffset : 0)
+    )
+    const requestedPageIndex = Number(progress && progress.pageIndex)
+    const chapterIndex = Number(chapter && chapter.index)
+
+    return {
+        chapterId: progress && progress.chapterId != null
+            ? progress.chapterId
+            : chapter && chapter.id != null
+                ? chapter.id
+                : '',
+        chapterIndex: Number.isFinite(chapterIndex)
+            ? chapterIndex
+            : Number(progress && progress.chapterIndex) || 0,
+        pageIndex: Math.max(0, Number.isFinite(requestedPageIndex) ? requestedPageIndex : 0),
+        pageCount: Math.max(0, Number(progress && progress.pageCount) || 0),
+        charOffset,
+        chapterProgress: contentLength
+            ? Math.min(1, Math.max(0, charOffset / contentLength))
+            : 0,
+        totalProgress: Math.min(1, Math.max(0, Number(progress && progress.totalProgress) || 0)),
+        scrollTop: Math.max(0, Number(progress && progress.scrollTop) || 0),
+        updatedAt: Number(progress && progress.updatedAt) || 0
+    }
+}
+
+export default {
+    normalizeContent,
+    normalizeProgress
+}