uview-plus 3.8.55 → 3.8.106

package/components/u-waterfall/u-waterfall.vue

@@ -92,10 +92,14 @@
             return {
                 columnList: [[]], // 存储每列的数据
                 children: [],
-                // 用于标记是否已经初始化
-                initialized: false,
-                windowWidth: 375,
-                windowHeight: 0
+                // 用于标记是否已经初始化
+                initialized: false,
+                windowWidth: 375,
+                windowHeight: 0,
+                distributionQueue: [],
+                distributionRunning: false,
+                distributionPromise: null,
+                distributionGeneration: 0
             }
         },
         watch: {
@@ -107,22 +111,27 @@
                         if (this.columnList.length == 1) {
                             this.initColumnList()
                         }
-                        // 取差值，即这一次数组变化新增的部分
-                        let startIndex = Array.isArray(oVal) && oVal.length > 0 ? oVal.length : 0;
-                        // 直接处理数据，不再使用tempList和splitData
-                        this.handleData(nVal.slice(startIndex));
+                        if (!this.isPureAppend(nVal, oVal)) {
+                            this.redistributeData(nVal);
+                            return;
+                        }
+                        // 取差值，即这一次数组变化新增的部分
+                        const startIndex = Array.isArray(oVal) && oVal.length > 0 ? oVal.length : 0;
+                        // 纯追加时只将新增数据加入共享分配队列
+                        this.handleData(nVal.slice(startIndex));
                     }
                 },
                 immediate: true
             },
-            columns: {
-                handler() {
-                    this.initColumnList();
-                    // 重新分配数据
-                    if (this.copyFlowList.length > 0) {
-                        this.redistributeData();
-                    }
-                },
+            columns: {
+                handler() {
+                    // 重新分配数据
+                    if (this.copyFlowList.length > 0) {
+                        this.redistributeData(this.copyFlowList);
+                    } else {
+                        this.clear(false);
+                    }
+                },
                 immediate: false
             }
         },
@@ -210,101 +219,144 @@
                     const newColumnsCount = this.getColumnsCount();
                     const oldColumnsCount = this.columnList.length;
                     
-                    // 只有列数发生变化时才重新分配数据
-                    if (newColumnsCount !== oldColumnsCount) {
-                        this.redistributeData();
-                    }
-                }, 300);
-            },
-            
-            // 重新分配所有数据
-            async redistributeData() {
-                // 清空所有列
-                this.initColumnList();
-                // 保存所有数据
-                const allData = this.cloneData(this.copyFlowList);
-                // 重新分配数据
-                this.handleData(allData);
-            },
-            
-            // 处理新增数据
-            async handleData(newData) {
-                if (!newData || newData.length === 0) return;
-                
-                // 初始化列高度数组
-                const columnHeights = new Array(this.columnList.length).fill(0);
-                
-                // 获取各列当前高度
-                for (let i = 0; i < this.columnList.length; i++) {
-                    try {
-                        const rect = await this.$uGetRect(`#u-column-${i}`);
-                        // console.log(`#u-column-${i}`, rect.height)
-                        columnHeights[i] = rect.height || 0;
-                    } catch (e) {
-                        columnHeights[i] = 0;
-                    }
-                }
-                
-                // 分配新数据到最短的列
-                for (let item of newData) {
-                    const minHeightIndex = columnHeights.indexOf(Math.min(...columnHeights));
-                    // console.log('this.columnList', this.columnList)
-                    this.columnList[minHeightIndex].push(item);
-                    
-                    // 获取实际渲染后的元素高度而不是估算
-                    await sleep(this.addTime)
-                    await this.$nextTick(async () => {
-                        try {
-                            const rect = await this.$uGetRect(`#u-column-${minHeightIndex}`);
-                            // console.log(`#u-column-${minHeightIndex}`, rect.height)
-                            if (rect.height) {
-                                columnHeights[minHeightIndex] = rect.height;
-                                // 加载一个后置事件
-                                this.$emit('after-add-one', {
-                                    ...item,
-                                    height: rect.height
-                                });
-                            }
-                        } catch (e) {
-                            // console.log(e)
-                            // columnHeights[i] = 0;
-                        }
-                    });
-                    // this.$nextTick(async () => {
-                    //     try {
-                    //         // 等待DOM更新后获取实际高度
-                    //         const lastIndex = this.columnList[minHeightIndex].length - 1;
-                    //         const el = this.$refs[`u-column-${minHeightIndex}`][0].children[lastIndex];
-                    //         if (el) {
-                    //             const rect = await this.$uGetRect(el);
-                    //             const actualHeight = rect.height || 100;
-                    //             columnHeights[minHeightIndex] += actualHeight;
-                    //         } else {
-                    //             // 备用方案：如果无法获取实际高度，则使用默认值
-                    //             columnHeights[minHeightIndex] += 100;
-                    //         }
-                    //     } catch (e) {
-                    //         // 出错时使用默认高度
-                    //         console.log(e)
-                    //         columnHeights[minHeightIndex] += 100;
-                    //     }
-                    // });
-                }
-                // 加载所有后置事件
-                this.$emit('after-add-all', {
-                    columnHeights: columnHeights,
-                    newData: newData
-                });
-            },
-
-            // 复制而不是引用对象和数组
-            cloneData(data) {
-                return JSON.parse(JSON.stringify(data));
+                    // 只有列数发生变化时才重新分配数据
+                    if (newColumnsCount !== oldColumnsCount) {
+                        this.redistributeData(this.copyFlowList);
+                    }
+                }, 300);
+            },
+
+            // 重新分配所有数据
+            redistributeData(data = this.copyFlowList) {
+                this.clear(false);
+                // 保存所有数据
+                const allData = this.cloneData(data || []);
+                // 重新分配数据
+                return this.handleData(allData);
+            },
+
+            // 判断新数据是否只在原数组末尾追加
+            isPureAppend(newData, oldData) {
+                if (!Array.isArray(oldData) || oldData.length === 0) return true;
+                if (!Array.isArray(newData) || newData.length < oldData.length) return false;
+                return oldData.every((item, index) => {
+                    return JSON.stringify(item) === JSON.stringify(newData[index]);
+                });
+            },
+
+            // 将新增数据加入共享队列，确保只有一个分配循环运行
+            handleData(newData) {
+                if (!newData || newData.length === 0) {
+                    return this.distributionPromise || Promise.resolve();
+                }
+                this.distributionQueue.push({
+                    generation: this.distributionGeneration,
+                    data: this.cloneData(newData)
+                });
+                if (!this.distributionRunning) {
+                    this.distributionPromise = this.runDistributionQueue();
+                }
+                return this.distributionPromise;
+            },
+
+            // 串行消费所有待分配数据
+            async runDistributionQueue() {
+                if (this.distributionRunning) return;
+                this.distributionRunning = true;
+                try {
+                    while (this.distributionQueue.length > 0) {
+                        const task = this.distributionQueue.shift();
+                        if (task.generation !== this.distributionGeneration) continue;
+                        await this.distributeData(task.data, task.generation);
+                    }
+                } finally {
+                    this.distributionRunning = false;
+                    this.distributionPromise = null;
+                    if (this.distributionQueue.length > 0) {
+                        this.distributionPromise = this.runDistributionQueue();
+                    }
+                }
+            },
+
+            // 逐项测量并分配数据，代数变化时立即退出
+            async distributeData(newData, generation) {
+                let columnHeights = new Array(this.columnList.length).fill(0);
+                for (const item of newData) {
+                    if (generation !== this.distributionGeneration) return;
+                    columnHeights = await this.getColumnHeights();
+                    if (generation !== this.distributionGeneration) return;
+
+                    const minHeightIndex = this.getMinHeightColumnIndex(columnHeights);
+                    this.columnList[minHeightIndex].push(item);
+
+                    await sleep(this.addTime);
+                    if (generation !== this.distributionGeneration) return;
+                    await this.$nextTick();
+                    if (generation !== this.distributionGeneration) return;
+                    try {
+                        const rect = await this.$uGetRect(`#u-column-${minHeightIndex}`);
+                        if (generation !== this.distributionGeneration) return;
+                        if (rect.height) {
+                            columnHeights[minHeightIndex] = rect.height;
+                            this.$emit('after-add-one', {
+                                ...item,
+                                height: rect.height
+                            });
+                        }
+                    } catch (e) {
+                        // 获取不到列高时，下一个元素会重新测量所有列
+                    }
+                }
+                if (generation !== this.distributionGeneration) return;
+                this.$emit('after-add-all', {
+                    columnHeights: columnHeights,
+                    newData: newData
+                });
+            },
+
+            // 获取当前所有列的真实高度
+            async getColumnHeights() {
+                const columnHeights = new Array(this.columnList.length).fill(0);
+                for (let i = 0; i < this.columnList.length; i++) {
+                    try {
+                        const rect = await this.$uGetRect(`#u-column-${i}`);
+                        columnHeights[i] = rect.height || 0;
+                    } catch (e) {
+                        columnHeights[i] = 0;
+                    }
+                }
+                return columnHeights;
+            },
+
+            // 获取最短列；高度相同或暂不可测时按列数据量打散，避免全部落到第一列
+            getMinHeightColumnIndex(columnHeights) {
+                let minIndex = 0;
+                for (let i = 1; i < columnHeights.length; i++) {
+                    const currentHeight = Number(columnHeights[i]) || 0;
+                    const minHeight = Number(columnHeights[minIndex]) || 0;
+                    if (currentHeight < minHeight) {
+                        minIndex = i;
+                    } else if (currentHeight === minHeight) {
+                        const currentLength = this.columnList[i] ? this.columnList[i].length : 0;
+                        const minLength = this.columnList[minIndex] ? this.columnList[minIndex].length : 0;
+                        if (currentLength < minLength) {
+                            minIndex = i;
+                        }
+                    }
+                }
+                return minIndex;
+            },
+
+            // 复制而不是引用对象和数组
+            cloneData(data) {
+                return JSON.parse(JSON.stringify(data));
             },
             
-            // 清空数据列表
-            clear(bak = true) {
-                this.initColumnList();
+            // 清空数据列表
+            clear(bak = true) {
+                this.distributionGeneration += 1;
+                this.distributionQueue.splice(0);
+                this.initColumnList();
                 // 同时清除父组件列表中的数据
                 if (bak) {
                     // #ifdef VUE2
@@ -413,4 +465,4 @@
         max-width: 100%;
         /* #endif */
     }
-</style>
+</style>

package/index.js

@@ -1,3 +1,7 @@
+// 补齐部分平台缺失的 uni API（如支付宝小程序的 onWindowResize）
+import { applyUniApiShims } from './libs/function/uni-api-shims.js'
+applyUniApiShims()
+
 // 看到此报错，是因为没有配置vite.config.js的【transpileDependencies】
 // const pleaseSetTranspileDependencies = {}, babelTest = pleaseSetTranspileDependencies?.test
 
@@ -27,7 +31,7 @@ import index, { rpx2px } from './libs/function/index.js'
 // 配置信息
 import config from './libs/config/config.js'
 // props配置信息
-import props from './libs/config/props.js'
+import props, { setPropsConfig } from './libs/config/props.js'
 // 各个需要fixed的地方的z-index配置文件
 import zIndex from './libs/config/zIndex.js'
 // 关于颜色的配置，特殊场景使用
@@ -42,7 +46,26 @@ import http from './libs/function/http.js'
 import fontUtil from './components/u-icon/util.js';
 
 // i18n
-import i18n, { t } from './libs/i18n/index.js'
+import i18n, {
+    t,
+    registerLocale,
+    hasLocale,
+    getLocale,
+    setLocale
+} from './libs/i18n/index.js'
+import {
+    en,
+    es,
+    fr,
+    de,
+    ko,
+    ja,
+    ru,
+    th,
+    zhHans,
+    zhHant,
+    all as allLocales
+} from './libs/i18n/locale-packs.js'
 import {
     themeState,
     setTheme,
@@ -135,7 +158,41 @@ function rootNotify(options = {}) {
 
 // 导出
 let themeType = ['primary', 'success', 'error', 'warning', 'info'];
-export { route, http, debounce, throttle, calc, digit, platform, themeType, mixin, mpMixin, props, color, test, zIndex, fontUtil, i18n , rpx2px, t}
+export {
+    route,
+    http,
+    debounce,
+    throttle,
+    calc,
+    digit,
+    platform,
+    themeType,
+    mixin,
+    mpMixin,
+    props,
+    color,
+    test,
+    zIndex,
+    fontUtil,
+    i18n,
+    rpx2px,
+    t,
+    registerLocale,
+    hasLocale,
+    getLocale,
+    setLocale,
+    en,
+    es,
+    fr,
+    de,
+    ko,
+    ja,
+    ru,
+    th,
+    zhHans,
+    zhHant,
+    allLocales
+}
 export * from './libs/function/index.js'
 export * from './libs/function/colorGradient.js'
 
@@ -149,7 +206,7 @@ export * from './libs/function/colorGradient.js'
 export function setConfig(configs) {
     const settings = configs || {}
 	index.shallowMerge(config, settings.config || {})
-	index.shallowMerge(props, settings.props || {})
+	setPropsConfig(settings.props || {})
 	index.shallowMerge(color, settings.color || {})
 	index.shallowMerge(zIndex, settings.zIndex || {})
     syncThemeColorOverrideState({
@@ -182,7 +239,7 @@ const $u = {
 	calc,
     mixin,
     mpMixin,
-    // props,
+    props,
     ...index,
     color,
     platform,
@@ -253,8 +310,8 @@ let components = []
 function resolveComponents() {
     if (components.length) return components
     // #ifdef H5
-    const canUseGlob = typeof import.meta !== 'undefined' && typeof import.meta.glob === 'function'
-    if (!canUseGlob) return components
+    // import.meta.glob is a Vite compile-time macro; the runtime guard would
+    // always fail in the browser and block component registration.
     const importFn = import.meta.glob('./components/u-*/u-*.vue', { eager: true })
     for (const key in importFn) {
         const component = importFn[key]?.default
@@ -305,4 +362,4 @@ const install = (Vue, upuiParams = '') => {
 
 export default {
     install
-}
+}

package/libs/config/config.js

@@ -54,5 +54,5 @@ export default {
 		navbarLeftClick: null
 	},
     // 只加载一次字体
-    loadFontOnce: false
+    loadFontOnce: true
 }