@zwa73/utils 1.0.188 → 1.0.189

package/dist/UtilFunctions.js

@@ -188,7 +188,7 @@ class UtilFunc {
             //根据最大重试次数限制进行循环
             for (let i = 0; i < count;) {
                 if (i > 0 && opt.tryDelay)
-                    await this.sleep(opt.tryDelay);
+                    await UtilFunc.sleep(opt.tryDelay);
                 UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 repeatPromise`);
                 //如果 plist 中当前下标的任务还未创建 则 创建当前任务
                 if (plist.length < i + 1) {
@@ -396,11 +396,12 @@ class UtilFunc {
      */
     static queueProc(flag, task) {
         // 如果当前标签的队列不存在，则创建一个新的队列
-        if (!this.pendingMap[flag])
-            this.pendingMap[flag] = [];
+        if (!UtilFunc.pendingMap[flag])
+            UtilFunc.pendingMap[flag] = [];
         // 创建一个新的Promise，并保存resolve函数以便后续调用
         let resolveFunc;
-        const promise = new Promise((resolve) => {
+        let rejectFunc;
+        const promise = new Promise((resolve, reject) => {
             resolveFunc = resolve;
         });
         // 定义处理任务的函数
@@ -414,25 +415,26 @@ class UtilFunc {
             }
             catch (error) {
                 // 如果任务执行出错，记录错误日志
-                UtilLogger_1.SLogger.warn(`queueProc 错误: `, error, `flag: ${String(flag)}`);
+                UtilLogger_1.SLogger.warn(`queueProc 错误 flag: ${String(flag)} 已抛出`);
+                rejectFunc(error);
             }
             finally {
                 // 无论任务是否成功，都从队列中移除当前任务
-                this.pendingMap[flag].shift();
+                UtilFunc.pendingMap[flag].shift();
                 // 如果队列中还有任务，执行下一个任务
-                if (this.pendingMap[flag].length > 0) {
-                    this.pendingMap[flag][0]();
+                if (UtilFunc.pendingMap[flag].length > 0) {
+                    UtilFunc.pendingMap[flag][0]();
                 }
                 else {
                     // 如果队列中没有任务，删除队列
-                    delete this.pendingMap[flag];
+                    delete UtilFunc.pendingMap[flag];
                 }
             }
         };
         // 将处理任务的函数添加到队列中
-        this.pendingMap[flag].push(processTask);
+        UtilFunc.pendingMap[flag].push(processTask);
         // 如果队列中只有当前任务，立即执行
-        if (this.pendingMap[flag].length === 1)
+        if (UtilFunc.pendingMap[flag].length === 1)
             processTask();
         // 返回Promise，以便调用者可以等待任务完成
         return promise;
@@ -441,7 +443,7 @@ class UtilFunc {
      * @param flag - 队列标签
      */
     static queueLength(flag) {
-        const pd = this.pendingMap[flag];
+        const pd = UtilFunc.pendingMap[flag];
         return pd != null ? pd.length : 0;
     }
     /**创建一个Outcome */
@@ -728,7 +730,10 @@ class UtilFunc {
     static parseSrtTime(time) {
         const [hours, minutes, seconds] = time.split(':');
         const [secs, milliseconds] = seconds.split(',');
-        return parseInt(hours) * 3600000 + parseInt(minutes) * 60000 + parseInt(secs) * 1000 + parseInt(milliseconds);
+        return parseInt(hours) * 3600000 +
+            parseInt(minutes) * 60000 +
+            parseInt(secs) * 1000 +
+            parseInt(milliseconds);
     }
     /**将毫秒转换为hh:mm:ss,ms格式 */
     static formatSrtTime(milliseconds) {
@@ -748,7 +753,8 @@ class UtilFunc {
             if (!id)
                 continue;
             const timeRange = srtLines[index++].trim();
-            const [start, end] = timeRange.split(' --> ').map(time => UtilFunc.parseSrtTime(time));
+            const [start, end] = timeRange.split(' --> ')
+                .map(time => UtilFunc.parseSrtTime(time));
             let text = '';
             while (index < srtLines.length && srtLines[index].trim())
                 text += `${srtLines[index++]}\n`;

package/package.json

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

package/src/UtilFunctions.ts

@@ -249,7 +249,7 @@ Promise<RepeatPromiseResult<T>>{
     try{
         //根据最大重试次数限制进行循环
         for(let i=0;i<count;){
-            if(i>0 && opt.tryDelay) await this.sleep(opt.tryDelay);
+            if(i>0 && opt.tryDelay) await UtilFunc.sleep(opt.tryDelay);
             SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
             //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){
@@ -468,11 +468,12 @@ static pendingMap:Record<Keyable,AnyFunc[]> = {};
  */
 static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
     // 如果当前标签的队列不存在，则创建一个新的队列
-    if (!this.pendingMap[flag]) this.pendingMap[flag] = [];
+    if (!UtilFunc.pendingMap[flag]) UtilFunc.pendingMap[flag] = [];
 
     // 创建一个新的Promise，并保存resolve函数以便后续调用
     let resolveFunc: (value: T | PromiseLike<T>) => void;
-    const promise = new Promise<T>((resolve) => {
+    let rejectFunc: (value: any | PromiseLike<any>) => void;
+    const promise = new Promise<T>((resolve,reject) => {
         resolveFunc = resolve;
     });
 
@@ -486,24 +487,25 @@ static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
             resolveFunc(result);
         } catch (error) {
             // 如果任务执行出错，记录错误日志
-            SLogger.warn(`queueProc 错误: `,error,`flag: ${String(flag)}`);
+            SLogger.warn(`queueProc 错误 flag: ${String(flag)} 已抛出`);
+            rejectFunc(error);
         } finally {
             // 无论任务是否成功，都从队列中移除当前任务
-            this.pendingMap[flag].shift();
+            UtilFunc.pendingMap[flag].shift();
             // 如果队列中还有任务，执行下一个任务
-            if (this.pendingMap[flag].length > 0) {
-                this.pendingMap[flag][0]();
+            if (UtilFunc.pendingMap[flag].length > 0) {
+                UtilFunc.pendingMap[flag][0]();
             } else {
                 // 如果队列中没有任务，删除队列
-                delete this.pendingMap[flag];
+                delete UtilFunc.pendingMap[flag];
             }
         }
     };
 
     // 将处理任务的函数添加到队列中
-    this.pendingMap[flag].push(processTask);
+    UtilFunc.pendingMap[flag].push(processTask);
     // 如果队列中只有当前任务，立即执行
-    if (this.pendingMap[flag].length === 1) processTask();
+    if (UtilFunc.pendingMap[flag].length === 1) processTask();
 
     // 返回Promise，以便调用者可以等待任务完成
     return promise;
@@ -512,7 +514,7 @@ static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
  * @param flag - 队列标签
  */
 static queueLength(flag:Keyable){
-    const pd = this.pendingMap[flag]
+    const pd = UtilFunc.pendingMap[flag]
     return pd!=null ? pd.length : 0;
 }
 
@@ -861,7 +863,10 @@ static parseSrtTime(time: string): number {
     const [hours, minutes, seconds] = time.split(':');
     const [secs, milliseconds] = seconds.split(',');
 
-    return parseInt(hours) * 3600000 + parseInt(minutes) * 60000 + parseInt(secs) * 1000 + parseInt(milliseconds);
+    return parseInt(hours) * 3600000 +
+        parseInt(minutes) * 60000 +
+        parseInt(secs) * 1000 +
+        parseInt(milliseconds);
 }
 /**将毫秒转换为hh:mm:ss,ms格式 */
 static formatSrtTime(milliseconds: number): string {
@@ -883,7 +888,8 @@ static parseSrt(srtText: string): SrtSegment[] {
         if (!id) continue;
 
         const timeRange = srtLines[index++].trim();
-        const [start, end] = timeRange.split(' --> ').map(time => UtilFunc.parseSrtTime(time));
+        const [start, end] = timeRange.split(' --> ')
+            .map(time => UtilFunc.parseSrtTime(time));
 
         let text = '';
         while (index < srtLines.length && srtLines[index].trim())