@zwa73/utils 1.0.43 → 1.0.45

package/dist/UtilCom.d.ts

@@ -1,22 +1,46 @@
-import { JObject } from "./UtilInterfaces";
+import { JObject, PromiseVerifyFn } from "./UtilInterfaces";
 /**网络工具 */
 export declare namespace UtilCom {
-    /**发送一个POST请求并接受数据
+    /**发送一个 https POST请求并接受数据
      * Object ()
      * @async
      * @param {JObject} json 	   - 数据对象
      * @param {Object} options     - 参数对象
      * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
-     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
      */
     function shttpsPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
-    /**发送一个POST请求并接受数据
+    /**发送一个 http POST请求并接受数据
      * Object ()
      * @async
      * @param {JObject} json 	   - 数据对象
      * @param {Object} options     - 参数对象
      * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
-     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
      */
     function shttpPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
+    /**重复一个 https POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     */
+    function shttpsRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, verifyFn?: PromiseVerifyFn<JObject | null>): Promise<JObject | null>;
+    /**重复一个 http POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     */
+    function shttpRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, verifyFn?: PromiseVerifyFn<JObject | null>): Promise<JObject | null>;
 }

package/dist/UtilCom.js

@@ -5,16 +5,24 @@ const UtilInterfaces_1 = require("./UtilInterfaces");
 const https = require("https");
 const http = require("http");
 const UtilLogger_1 = require("./UtilLogger");
+const UtilFunctions_1 = require("./UtilFunctions");
 /**网络工具 */
 var UtilCom;
 (function (UtilCom) {
-    function sPost(type, json, options, timeLimit = -1) {
+    /**通用post处理
+     * @param {"http"|"https"} posttype - post类型
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
+     */
+    function sPost(posttype, json, options, timeLimit = -1) {
         //转换为毫秒
         const hasTimeLimit = (timeLimit >= 10);
         if (hasTimeLimit)
             timeLimit *= 1000;
         const jsonStr = (0, UtilInterfaces_1.stringifyJToken)(json);
-        const funcName = "s" + type + "Psot";
+        const funcName = "s" + posttype + "Psot";
         return new Promise((resolve, rejecte) => {
             const resFunc = (res) => {
                 try {
@@ -62,9 +70,9 @@ var UtilCom;
             };
             //路由 http/https
             let req = null;
-            if (type === "https")
+            if (posttype === "https")
                 req = https.request(options, resFunc);
-            else if (type === "http")
+            else if (posttype === "http")
                 req = http.request(options, resFunc);
             //请求超时
             if (hasTimeLimit) {
@@ -81,28 +89,73 @@ var UtilCom;
             req.end();
         });
     }
-    /**发送一个POST请求并接受数据
+    /**发送一个 https POST请求并接受数据
      * Object ()
      * @async
      * @param {JObject} json 	   - 数据对象
      * @param {Object} options     - 参数对象
      * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
-     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
      */
     function shttpsPost(json, options, timeLimit = -1) {
         return sPost("https", json, options, timeLimit);
     }
     UtilCom.shttpsPost = shttpsPost;
-    /**发送一个POST请求并接受数据
+    /**发送一个 http POST请求并接受数据
      * Object ()
      * @async
      * @param {JObject} json 	   - 数据对象
      * @param {Object} options     - 参数对象
      * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
-     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
      */
     function shttpPost(json, options, timeLimit = -1) {
         return sPost("http", json, options, timeLimit);
     }
     UtilCom.shttpPost = shttpPost;
+    /**通用重复post处理
+     * @async
+     * @param {"http"|"https"} posttype - post类型
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     */
+    async function sRepeatPost(posttype, json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, verifyFn) {
+        const procFn = () => sPost(posttype, json, options, timeLimit);
+        return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, repeatCount, repeatTime);
+    }
+    /**重复一个 https POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     */
+    function shttpsRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, verifyFn) {
+        return sRepeatPost("https", json, options, timeLimit, repeatCount, repeatTime, verifyFn);
+    }
+    UtilCom.shttpsRepeatPost = shttpsRepeatPost;
+    /**重复一个 http POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     */
+    function shttpRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, verifyFn) {
+        return sRepeatPost("http", json, options, timeLimit, repeatCount, repeatTime, verifyFn);
+    }
+    UtilCom.shttpRepeatPost = shttpRepeatPost;
 })(UtilCom = exports.UtilCom || (exports.UtilCom = {}));

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { JToken } from "./UtilInterfaces";
+import { JToken, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
 /**常用函数 */
 export declare namespace UtilFunc {
     /**获取当前时间戳
@@ -51,4 +51,6 @@ export declare namespace UtilFunc {
     }>;
     /**获得一个永不完成的Promise单例 */
     function getNeverResolvedPromise<T>(): Promise<T>;
+    /**重复尝试promise */
+    function repeatPromise<T>(procFn: PromiseProcFn<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
 }

package/dist/UtilFunctions.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilFunc = void 0;
 const crypto = require("crypto");
 const cp = require("child_process");
+const UtilLogger_1 = require("./UtilLogger");
 /**常用函数 */
 var UtilFunc;
 (function (UtilFunc) {
@@ -98,4 +99,82 @@ var UtilFunc;
         return NeverResolvedPromise;
     }
     UtilFunc.getNeverResolvedPromise = getNeverResolvedPromise;
+    /**重复尝试promise */
+    async function repeatPromise(procFn, verifyFn, repeatCount = 3, repeatTime = 180) {
+        //转换为毫秒
+        const hasRepeatTime = (repeatTime >= 10);
+        if (hasRepeatTime)
+            repeatTime *= 1000;
+        //验证处理函数
+        if (verifyFn === undefined)
+            verifyFn = () => "Completed";
+        //计时器
+        let timer = null;
+        let timerP = null;
+        let resolveFn = null;
+        /**清理计时器 */
+        const clearTimer = () => {
+            if (timer != null)
+                clearInterval(timer);
+            if (resolveFn != null)
+                resolveFn("Timeout");
+            timerP = null;
+            timer = null;
+            resolveFn = null;
+        };
+        //进行中的请求
+        const plist = new Array(repeatCount)
+            .fill(UtilFunc.getNeverResolvedPromise());
+        for (let i = 0; i < repeatCount;) {
+            UtilLogger_1.SLogger.info("开始第 " + (i + 1) + " 次 repeatPromise");
+            //创建当前任务
+            plist[i] = procFn().then(result => ({ result, stat: verifyFn(result), index: i }));
+            //创建定时器
+            if (timerP == null) {
+                timerP = new Promise(function (resolve, rejecte) {
+                    resolveFn = resolve;
+                    timer = setTimeout(() => resolve("Timeout"), hasRepeatTime ? repeatTime : Infinity); //无限制则无限时间
+                });
+            }
+            //等待完成
+            const currObj = await Promise.race([...plist, timerP]);
+            //超时处理
+            if (currObj == "Timeout") {
+                UtilLogger_1.SLogger.warn(`第 ${(i + 1)} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
+                clearTimer();
+                i++;
+                continue;
+            }
+            else {
+                const poststat = await currObj.stat;
+                switch (poststat) {
+                    case "Completed": //完成
+                        UtilLogger_1.SLogger.info("第 " + (currObj.index + 1) + " 次 repeatPromise 成功");
+                        clearTimer();
+                        return currObj.result;
+                    case "Terminated": //终止
+                        UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 repeatPromise 终止 停止重试");
+                        clearTimer();
+                        return currObj.result;
+                    case "Failed": //验证失败
+                        //是当前
+                        if (currObj.index == i) {
+                            UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 repeatPromise 失败 开始重试");
+                            clearTimer();
+                            i++;
+                            continue;
+                        }
+                        //非当前
+                        UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 repeatPromise 失败");
+                        //抛弃失败
+                        plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                        continue;
+                }
+            }
+        }
+        clearTimer();
+        //全部失败或超时则返回null
+        return null;
+    }
+    UtilFunc.repeatPromise = repeatPromise;
 })(UtilFunc = exports.UtilFunc || (exports.UtilFunc = {}));

package/dist/UtilInterfaces.d.ts

@@ -54,4 +54,22 @@ type ExclusiveRecursive<B, T, K extends string[], R extends unknown[] = []> = R[
 export type ExclusiveRecord<B, T, K extends string[], TMP = ExclusiveRecursive<B, T, K>> = TMP[keyof TMP];
 /**符合JObject约束的互斥表 */
 export type ExclusiveJObject<B extends JObject, T extends JToken, K extends string[], TMP extends JArray = ExclusiveRecursive<B, T, K>> = TMP[number];
+/**进行中的请求 */
+export type ProcessingPromise<T> = {
+    /**主体请求 */
+    result: T;
+    /**请求状态 */
+    stat: PromiseStat | Promise<PromiseStat>;
+    /**请求下标/序号 */
+    index: number;
+};
+/**请求完成状态 成功/失败/终止
+ * 成功/终止 将直接返回
+ * 失败 将重试
+ */
+export type PromiseStat = "Completed" | "Failed" | "Terminated";
+/**promise验证函数 */
+export type PromiseVerifyFn<T> = (obj: T) => Promise<PromiseStat> | PromiseStat;
+/**发起promise的函数 */
+export type PromiseProcFn<T> = () => Promise<T>;
 export {};

package/package.json

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

package/src/UtilCom.ts

@@ -1,20 +1,28 @@
-import { JObject, stringifyJToken } from "./UtilInterfaces";
+import { JObject, ProcessingPromise, PromiseVerifyFn, stringifyJToken } from "./UtilInterfaces";
 import * as https from 'https';
 import * as http from 'http';
 import { SLogger } from "./UtilLogger";
+import { UtilFunc } from "./UtilFunctions";
 
 
 /**网络工具 */
 export namespace UtilCom{
 
-function sPost(type:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
+/**通用post处理  
+ * @param {"http"|"https"} posttype - post类型
+ * @param {JObject} json 	        - 数据对象
+ * @param {Object} options          - 参数对象
+ * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+ * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
+ */
+function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
     //转换为毫秒
     const hasTimeLimit = (timeLimit>=10);
     if(hasTimeLimit)
         timeLimit*=1000
 
     const jsonStr = stringifyJToken(json);
-    const funcName = "s"+type+"Psot";
+    const funcName = "s"+posttype+"Psot";
 
     return new Promise((resolve, rejecte)=>{
         const resFunc = (res:http.IncomingMessage)=>{
@@ -65,9 +73,9 @@ function sPost(type:"http"|"https",json:JObject,options:Object,timeLimit:number=
         };
         //路由 http/https
         let req:http.ClientRequest=null as any as http.ClientRequest;
-        if(type === "https")
+        if(posttype === "https")
             req = https.request(options, resFunc);
-        else if(type === "http")
+        else if(posttype === "http")
             req = http.request(options, resFunc);
 
         //请求超时
@@ -88,27 +96,80 @@ function sPost(type:"http"|"https",json:JObject,options:Object,timeLimit:number=
     });
 }
 
-/**发送一个POST请求并接受数据
- * Object ()
+/**发送一个 https POST请求并接受数据  
+ * Object ()  
  * @async
  * @param {JObject} json 	   - 数据对象
  * @param {Object} options     - 参数对象
  * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
- * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+ * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
  */
 export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
     return sPost("https",json,options,timeLimit);
 }
 
-/**发送一个POST请求并接受数据
- * Object ()
+/**发送一个 http POST请求并接受数据  
+ * Object ()  
  * @async
  * @param {JObject} json 	   - 数据对象
  * @param {Object} options     - 参数对象
  * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
- * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+ * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
  */
 export function shttpPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
     return sPost("http",json,options,timeLimit);
 }
+
+
+
+/**通用重复post处理  
+ * @async
+ * @param {"http"|"https"} posttype - post类型
+ * @param {JObject} json 	        - 数据对象
+ * @param {Object} options          - 参数对象
+ * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+ * @param {number} [repeatCount]    - 重试次数
+ * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+ * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+ * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+ */
+async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
+    const procFn = ()=>sPost(posttype,json,options,timeLimit);
+    return UtilFunc.repeatPromise(procFn,verifyFn,repeatCount,repeatTime);
+}
+
+
+/**重复一个 https POST请求并接受数据  
+ * Object ()  
+ * @async
+ * @param {JObject} json 	        - 数据对象
+ * @param {Object} options          - 参数对象
+ * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+ * @param {number} [repeatCount]    - 重试次数
+ * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+ * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+ * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+ */
+export function shttpsRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
+    return sRepeatPost("https",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
+}
+
+/**重复一个 http POST请求并接受数据  
+ * Object ()  
+ * @async
+ * @param {JObject} json 	        - 数据对象
+ * @param {Object} options          - 参数对象
+ * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+ * @param {number} [repeatCount]    - 重试次数
+ * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+ * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+ * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+ */
+export function shttpRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
+    return sRepeatPost("http",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
+}
+
 }

package/src/UtilFunctions.ts

@@ -1,19 +1,20 @@
 import * as crypto from "crypto";
-import { JToken } from "./UtilInterfaces";
+import { JToken, ProcessingPromise, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
 import * as cp from "child_process";
+import { SLogger } from "./UtilLogger";
 
 /**常用函数 */
 export namespace UtilFunc{
-/**获取当前时间戳
- * number ()
+/**获取当前时间戳  
+ * number ()  
  * @returns {number} 时间戳
  */
 export function getTime(): number {
     return new Date().getTime();
 }
 
-/**初始化对象的字段
- * void (Object,string,any)
+/**初始化对象的字段  
+ * void (Object,string,any)  
  * @param {Record<string,T>} obj   - 所要初始化的对象
  * @param {string} field 		   - 所要初始化的字段
  * @param {T} defaultVal 		   - 默认值
@@ -28,15 +29,15 @@ export function initField<T>(
     return obj[field];
 }
 
-/**生成一串uuid
- * string ()
+/**生成一串uuid  
+ * string ()  
  * @returns {string} uuid
  */
 export function genUUID() {
     return crypto.randomBytes(16).toString("hex");
 }
-/**计算Hash
- * string ()
+/**计算Hash  
+ * string ()  
  * @param {string} str - 待计算的字符串
  * @returns {string} hash
  */
@@ -44,7 +45,7 @@ export function calcHash(str:string) {
     return crypto.createHash('md5').update(str).digest('hex');
 }
 
-/**深克隆 序列化并反序列化
+/**深克隆 序列化并反序列化  
  * @template {T} T - JToken类型的泛型
  * @param {T} obj - 克隆目标
  * @returns {T}   克隆结果
@@ -63,7 +64,7 @@ export function isSafeNumber(num: number): boolean {
     return false;
 }
 
-/**等待 timeMs 毫秒
+/**等待 timeMs 毫秒  
  * @async
  * @param {number} timeMs - 等待的毫秒数
  * @returns {Promise<boolean>}
@@ -76,7 +77,7 @@ export async function sleep(timeMs: number): Promise<boolean> {
     });
 }
 
-/**封装的 cp.exec 执行一段指令 指令完成后返回 Promise
+/**封装的 cp.exec 执行一段指令 指令完成后返回 Promise  
  * @param {string} command 指令文本
  */
 export function exec(command: string) {
@@ -97,5 +98,88 @@ export function getNeverResolvedPromise<T>():Promise<T>{
     return NeverResolvedPromise as Promise<T>;
 }
 
+/**重复尝试promise */
+export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:PromiseVerifyFn<T>,
+    repeatCount:number=3,repeatTime:number=180):Promise<T|null>{
+    //转换为毫秒
+    const hasRepeatTime = (repeatTime>=10);
+    if(hasRepeatTime) repeatTime*=1000;
+
+    //验证处理函数
+    if(verifyFn===undefined)
+        verifyFn = ()=>"Completed";
+
+    //计时器
+    let timer:NodeJS.Timer|null = null;
+    let timerP:Promise<"Timeout">|null=null;
+    let resolveFn:((value: "Timeout" | PromiseLike<"Timeout">)=>void)|null = null;
+    /**清理计时器 */
+    const clearTimer = ()=>{
+        if(timer!=null)
+            clearInterval(timer);
+        if(resolveFn!=null)
+            resolveFn("Timeout");
+        timerP=null;
+        timer=null;
+        resolveFn=null;
+    }
+
+    //进行中的请求
+	const plist:Promise<ProcessingPromise<T>>[] = new Array(repeatCount)
+        .fill(UtilFunc.getNeverResolvedPromise());
+    for(let i=0;i<repeatCount;){
+        SLogger.info("开始第 "+(i+1)+" 次 repeatPromise");
+        //创建当前任务
+        plist[i] = procFn().then(result =>
+            ({result, stat:verifyFn!(result), index:i}));
+
+        //创建定时器
+        if(timerP==null){
+            timerP = new Promise<"Timeout">(function(resolve, rejecte){
+                resolveFn = resolve;
+                timer = setTimeout(()=>resolve("Timeout"),
+                    hasRepeatTime? repeatTime:Infinity);//无限制则无限时间
+            })
+        }
+
+        //等待完成
+        const currObj = await Promise.race([...plist, timerP]);
+
+        //超时处理
+        if(currObj=="Timeout"){
+            SLogger.warn(`第 ${(i+1)} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
+            clearTimer(); i++;
+            continue;
+        }else{
+            const poststat = await currObj.stat;
+            switch(poststat){
+                case "Completed"://完成
+                    SLogger.info("第 "+(currObj.index+1)+" 次 repeatPromise 成功");
+                    clearTimer();
+                    return currObj.result;
+                case "Terminated"://终止
+                    SLogger.warn("第 "+(currObj.index+1)+" 次 repeatPromise 终止 停止重试");
+                    clearTimer();
+                    return currObj.result;
+                case "Failed"://验证失败
+                    //是当前
+                    if(currObj.index==i){
+                        SLogger.warn("第 "+(currObj.index+1)+" 次 repeatPromise 失败 开始重试");
+                        clearTimer(); i++;
+                        continue;
+                    }
+                    //非当前
+                    SLogger.warn("第 "+(currObj.index+1)+" 次 repeatPromise 失败");
+                    //抛弃失败
+                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                    continue;
+            }
+        }
+    }
+    clearTimer();
+    //全部失败或超时则返回null
+    return null;
+}
+
 }
 

package/src/UtilInterfaces.ts

@@ -70,3 +70,24 @@ export type ExclusiveRecord<B, T, K extends string[], TMP = ExclusiveRecursive<B
 /**符合JObject约束的互斥表 */
 export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string[],
     TMP extends JArray = ExclusiveRecursive<B,T,K>> = TMP[number];
+
+
+/**进行中的请求 */
+export type ProcessingPromise<T> = {
+    /**主体请求 */
+    result:T;
+    /**请求状态 */
+    stat:PromiseStat|Promise<PromiseStat>;
+    /**请求下标/序号 */
+    index:number;
+};
+
+/**请求完成状态 成功/失败/终止  
+ * 成功/终止 将直接返回  
+ * 失败 将重试  
+ */
+export type PromiseStat = "Completed"|"Failed"|"Terminated";
+/**promise验证函数 */
+export type PromiseVerifyFn<T> = (obj:T)=>Promise<PromiseStat>|PromiseStat;
+/**发起promise的函数 */
+export type PromiseProcFn<T> = ()=>Promise<T>;