@zwa73/utils 1.0.89 → 1.0.91

package/dist/UtilFunctions.d.ts

@@ -103,7 +103,7 @@ export declare class UtilFunc {
      * @param task - 任务逻辑
      * @returns 处理结果
      */
-    static queueProc<T>(flag: Keyable, task: (() => Promise<T>) | Promise<T>): Promise<T>;
+    static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T>;
     /**队列获取目标的代办事件数
      * @param flag - 队列标签
      */

package/dist/UtilFunctions.js

@@ -297,34 +297,48 @@ class UtilFunc {
      * @param task - 任务逻辑
      * @returns 处理结果
      */
-    static async queueProc(flag, task) {
-        this.pendingMap[flag] = this.pendingMap[flag] ?? [];
-        const pending = this.pendingMap[flag];
-        //尝试解除下个任务的等待
-        const tryRes = function () {
-            const thispd = pending;
-            const resolve = thispd.shift();
-            if (resolve)
-                resolve();
+    static queueProc(flag, task) {
+        // 如果当前标签的队列不存在，则创建一个新的队列
+        if (!this.pendingMap[flag])
+            this.pendingMap[flag] = [];
+        // 创建一个新的Promise，并保存resolve函数以便后续调用
+        let resolveFunc;
+        const promise = new Promise((resolve) => {
+            resolveFunc = resolve;
+        });
+        // 定义处理任务的函数
+        const processTask = async () => {
+            let result;
+            try {
+                // 执行任务并等待结果
+                result = await task();
+                // 使用保存的resolve函数来解决Promise
+                resolveFunc(result);
+            }
+            catch (error) {
+                // 如果任务执行出错，记录错误日志
+                UtilLogger_1.SLogger.warn(`queueProc 错误: `, error, `flag: ${String(flag)}`);
+            }
+            finally {
+                // 无论任务是否成功，都从队列中移除当前任务
+                this.pendingMap[flag].shift();
+                // 如果队列中还有任务，执行下一个任务
+                if (this.pendingMap[flag].length > 0) {
+                    this.pendingMap[flag][0]();
+                }
+                else {
+                    // 如果队列中没有任务，删除队列
+                    delete this.pendingMap[flag];
+                }
+            }
         };
-        //空时直接运行 非空时等待
-        if (pending.length <= 0)
-            pending.push(() => tryRes());
-        else
-            await new Promise((resolve) => pending.push(resolve));
-        try {
-            const result = typeof task === 'function'
-                ? await task()
-                : await task;
-            return result;
-        }
-        catch (e) {
-            UtilLogger_1.SLogger.fatal(`queuePromise 出现错误`, e);
-            throw e;
-        }
-        finally {
-            tryRes();
-        }
+        // 将处理任务的函数添加到队列中
+        this.pendingMap[flag].push(processTask);
+        // 如果队列中只有当前任务，立即执行
+        if (this.pendingMap[flag].length === 1)
+            processTask();
+        // 返回Promise，以便调用者可以等待任务完成
+        return promise;
     }
     /**队列获取目标的代办事件数
      * @param flag - 队列标签

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zwa73/utils",
-  "version": "1.0.89",
+  "version": "1.0.91",
   "description": "my utils",
   "main": "index.js",
   "scripts": {

package/src/UtilFunctions.ts

@@ -356,33 +356,47 @@ static pendingMap:Record<Keyable,AnyFunc[]> = {};
  * @param task - 任务逻辑
  * @returns 处理结果
  */
-static async queueProc<T>(flag:Keyable,task:(()=>Promise<T>)|Promise<T>):Promise<T> {
-    this.pendingMap[flag] = this.pendingMap[flag]??[];
-    const pending = this.pendingMap[flag];
-
-    //尝试解除下个任务的等待
-    const tryRes = function(){
-        const thispd = pending;
-        const resolve = thispd.shift();
-        if(resolve) resolve();
-    }
+static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
+    // 如果当前标签的队列不存在，则创建一个新的队列
+    if (!this.pendingMap[flag]) this.pendingMap[flag] = [];
+
+    // 创建一个新的Promise，并保存resolve函数以便后续调用
+    let resolveFunc: (value: T | PromiseLike<T>) => void;
+    const promise = new Promise<T>((resolve) => {
+        resolveFunc = resolve;
+    });
 
-    //空时直接运行 非空时等待
-    if (pending.length <= 0)
-        pending.push(()=>tryRes());
-    else await new Promise((resolve) => pending.push(resolve));
+    // 定义处理任务的函数
+    const processTask = async () => {
+        let result: T;
+        try {
+            // 执行任务并等待结果
+            result = await task();
+            // 使用保存的resolve函数来解决Promise
+            resolveFunc(result);
+        } catch (error) {
+            // 如果任务执行出错，记录错误日志
+            SLogger.warn(`queueProc 错误: `,error,`flag: ${String(flag)}`);
+        } finally {
+            // 无论任务是否成功，都从队列中移除当前任务
+            this.pendingMap[flag].shift();
+            // 如果队列中还有任务，执行下一个任务
+            if (this.pendingMap[flag].length > 0) {
+                this.pendingMap[flag][0]();
+            } else {
+                // 如果队列中没有任务，删除队列
+                delete this.pendingMap[flag];
+            }
+        }
+    };
 
-    try {
-        const result = typeof task === 'function'
-            ? await task()
-            : await task;
-        return result;
-    } catch(e){
-        SLogger.fatal(`queuePromise 出现错误`,e);
-        throw e;
-    }finally {
-        tryRes();
-    }
+    // 将处理任务的函数添加到队列中
+    this.pendingMap[flag].push(processTask);
+    // 如果队列中只有当前任务，立即执行
+    if (this.pendingMap[flag].length === 1) processTask();
+
+    // 返回Promise，以便调用者可以等待任务完成
+    return promise;
 }
 /**队列获取目标的代办事件数  
  * @param flag - 队列标签