uview-plus 3.8.113 → 3.8.119

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

@@ -92,14 +92,16 @@
             return {
                 columnList: [[]], // 存储每列的数据
                 children: [],
-                // 用于标记是否已经初始化
-                initialized: false,
-                windowWidth: 375,
-                windowHeight: 0,
-                distributionQueue: [],
-                distributionRunning: false,
-                distributionPromise: null,
-                distributionGeneration: 0
+                // 用于标记是否已经初始化
+                initialized: false,
+                windowWidth: 375,
+                windowHeight: 0,
+                distributionQueue: [],
+                distributionRunning: false,
+                distributionPromise: null,
+                distributionGeneration: 0,
+                // 每个分配循环持有独立令牌：锁被强制重置后新循环接管，旧循环恢复时只能安静退出
+                distributionRunToken: 0
             }
         },
         watch: {
@@ -111,27 +113,27 @@
                         if (this.columnList.length == 1) {
                             this.initColumnList()
                         }
-                        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));
+                        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() {
-                    // 重新分配数据
-                    if (this.copyFlowList.length > 0) {
-                        this.redistributeData(this.copyFlowList);
-                    } else {
-                        this.clear(false);
-                    }
-                },
+            columns: {
+                handler() {
+                    // 重新分配数据
+                    if (this.copyFlowList.length > 0) {
+                        this.redistributeData(this.copyFlowList);
+                    } else {
+                        this.clear(false);
+                    }
+                },
                 immediate: false
             }
         },
@@ -219,144 +221,161 @@
                     const newColumnsCount = this.getColumnsCount();
                     const oldColumnsCount = this.columnList.length;
                     
-                    // 只有列数发生变化时才重新分配数据
-                    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));
+                    // 只有列数发生变化时才重新分配数据
+                    if (newColumnsCount !== oldColumnsCount) {
+                        this.redistributeData(this.copyFlowList);
+                    }
+                }, 300);
+            },
+
+            // 重新分配所有数据
+            redistributeData(data = this.copyFlowList) {
+                // 强制重置锁状态，确保能重新开始分配
+                this.distributionRunning = false;
+                this.distributionPromise = null;
+                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;
+                const runToken = ++this.distributionRunToken;
+                try {
+                    while (this.distributionQueue.length > 0) {
+                        if (runToken !== this.distributionRunToken) return;
+                        const task = this.distributionQueue.shift();
+                        if (task.generation !== this.distributionGeneration) continue;
+                        await this.distributeData(task.data, task.generation, runToken);
+                    }
+                } finally {
+                    // 仅当自己仍是当前循环时才释放锁，否则会清掉接管者的运行状态
+                    if (runToken === this.distributionRunToken) {
+                        this.distributionRunning = false;
+                        this.distributionPromise = null;
+                        if (this.distributionQueue.length > 0) {
+                            this.distributionPromise = this.runDistributionQueue();
+                        }
+                    }
+                }
+            },
+
+            // 数据被重置或分配循环被接管时，当前循环应立即停止写入
+            isStaleDistribution(generation, runToken) {
+                return generation !== this.distributionGeneration
+                    || runToken !== this.distributionRunToken;
+            },
+
+            // 逐项测量并分配数据，代数或令牌变化时立即退出
+            async distributeData(newData, generation, runToken) {
+                let columnHeights = new Array(this.columnList.length).fill(0);
+                for (const item of newData) {
+                    if (this.isStaleDistribution(generation, runToken)) return;
+                    columnHeights = await this.getColumnHeights();
+                    if (this.isStaleDistribution(generation, runToken)) return;
+
+                    const minHeightIndex = this.getMinHeightColumnIndex(columnHeights);
+                    this.columnList[minHeightIndex].push(item);
+
+                    await sleep(this.addTime);
+                    if (this.isStaleDistribution(generation, runToken)) return;
+                    await this.$nextTick();
+                    if (this.isStaleDistribution(generation, runToken)) return;
+                    try {
+                        const rect = await this.$uGetRect(`#u-column-${minHeightIndex}`);
+                        if (this.isStaleDistribution(generation, runToken)) return;
+                        if (rect.height) {
+                            columnHeights[minHeightIndex] = rect.height;
+                            this.$emit('after-add-one', {
+                                ...item,
+                                height: rect.height
+                            });
+                        }
+                    } catch (e) {
+                        // 获取不到列高时，下一个元素会重新测量所有列
+                    }
+                }
+                if (this.isStaleDistribution(generation, runToken)) 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.distributionGeneration += 1;
-                this.distributionQueue.splice(0);
-                this.initColumnList();
+            // 清空数据列表
+            clear(bak = true) {
+                this.distributionGeneration += 1;
+                this.distributionQueue.splice(0);
+                // 强制重置分配锁状态，避免页面隐藏导致的永久锁死
+                this.distributionRunning = false;
+                this.distributionPromise = null;
+                this.initColumnList();
                 // 同时清除父组件列表中的数据
                 if (bak) {
                     // #ifdef VUE2
@@ -465,4 +484,4 @@
         max-width: 100%;
         /* #endif */
     }
-</style>
+</style>

package/libs/function/index.js

@@ -17,6 +17,20 @@ function emptyNodeInfo() {
 	}
 }
 
+// 组件卸载后仍把它交给原生查询，APP 端会拿已失效的 nodeId 去查视图层映射表，
+// 读到 undefined 再取 .$ 就抛 Cannot read properties of undefined (reading '$')
+function isCompUnmounted(comp) {
+	if (!comp) {
+		return false
+	}
+	// 公共 mixin 的 beforeUnmount 里同步置位
+	if (comp.__upUnmounted) {
+		return true
+	}
+	// 未应用公共 mixin 时退回 Vue 自身标记：公开实例挂在 $ 上，内部实例直接持有
+	return !!(comp.$ ? comp.$.isUnmounted : comp.isUnmounted)
+}
+
 // #ifdef APP-NVUE
 const dom = (typeof uni !== 'undefined' && uni && typeof uni.requireNativePlugin === 'function')
 	? uni.requireNativePlugin('dom')
@@ -37,6 +51,10 @@ function getNvueRect(ref) {
 
 // 查询节点信息
 export function upGetRect(selector, all = false, comp = null) {
+	// 判定必须放在条件编译之外，否则 app-harmony 上整段会被裁掉
+	if (isCompUnmounted(comp)) {
+		return Promise.resolve(all ? [] : emptyNodeInfo())
+	}
 	return new Promise((resolve) => {
 		// #ifndef APP-NVUE
 		const query = uni.createSelectorQuery()
@@ -70,6 +88,17 @@ export function upGetRect(selector, all = false, comp = null) {
 	})
 }
 
+// 卸载后替代真实观察器，保持链式调用不报错
+function noopIntersectionObserver() {
+	const observer = {
+		relativeTo: () => observer,
+		relativeToViewport: () => observer,
+		observe: () => {},
+		disconnect: () => {}
+	}
+	return observer
+}
+
 // 创建交叉观察器
 // 小程序端 uni.createIntersectionObserver(vm) 会把 Vue 实例代理直接透传给原生 API，
 // 原生内部的 Object.keys(vm) 会触发告警：
@@ -77,6 +106,10 @@ export function upGetRect(selector, all = false, comp = null) {
 // （uni-app 只给 createSelectorQuery 做了 $scope 解包，没给 createIntersectionObserver 做）
 // 组件实例上的同名方法内部使用 $scope（原生组件实例），不会把代理外泄，因此优先使用
 export function upCreateIntersectionObserver(comp, options) {
+	// 和 upGetRect 同理：APP 端 addIntersectionObserver 也走 window.__$__(id).$ 查表
+	if (isCompUnmounted(comp)) {
+		return noopIntersectionObserver()
+	}
 	// 各家小程序与 H5 都在组件实例上暴露了该方法，内部已完成实例解包
 	if (comp && typeof comp.createIntersectionObserver === 'function') {
 		return options ? comp.createIntersectionObserver(options) : comp.createIntersectionObserver()

package/libs/mixin/mixin.js

@@ -251,6 +251,9 @@ export const mixin = defineMixin({
         uni.$emit('uOnReachBottom')
 	},
 	beforeUnmount() {
+        // mixin 的钩子先于组件自身钩子同步执行，比 Vue 内部的 $.isUnmounted
+        // （在 post-render 队列里异步置位）更早，异步回调据此拦截节点查询
+        this.__upUnmounted = true
         // 判断当前页面是否存在parent和chldren，一般在checkbox和checkbox-group父子联动的场景会有此情况
         // 组件销毁时，移除子组件在父组件children数组中的实例，释放资源，避免数据混乱
         if (this.parent && test.array(this.parent.children)) {

package/package.json

@@ -2,7 +2,7 @@
   "id": "uview-plus",
   "name": "uview-plus",
   "displayName": "零云®uview-plus3.0重磅发布，全面的Vue3鸿蒙跨端移动组件库，组件丰富维护更新稳定。",
-  "version": "3.8.113",
+  "version": "3.8.119",
   "description": "零云®uview-plus已兼容vue3支持多语言，120+全面的组件和便捷的工具会让您信手拈来。近期新增拖动排序、条码、图片裁剪、下拉刷新、虚拟列表、签名、Markdown等。",
   "keywords": [
     "uview",
@@ -11,7 +11,7 @@
     "echarts",
     "ui",
     "可视化"
-],
+  ],
   "main": "index.js",
   "repository": "https://github.com/ijry/uview-plus",
   "engines": {