@zwa73/utils 1.0.44 → 1.0.45

package/dist/UtilCom.d.ts

@@ -1,4 +1,4 @@
-import { JObject } from "./UtilInterfaces";
+import { JObject, PromiseVerifyFn } from "./UtilInterfaces";
 /**网络工具 */
 export declare namespace UtilCom {
     /**发送一个 https POST请求并接受数据
@@ -7,7 +7,7 @@ export declare namespace UtilCom {
      * @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>;
     /**发送一个 http POST请求并接受数据
@@ -16,16 +16,9 @@ export declare namespace UtilCom {
      * @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>;
-    /**请求完成状态 成功/失败/终止
-     * 成功/终止 将直接返回
-     * 失败 将重试
-     */
-    type PostStat = "Completed" | "Failed" | "Terminated";
-    /**post处理函数 */
-    type PostProc = (respObj: JObject | null) => Promise<PostStat> | PostStat;
     /**重复一个 https POST请求并接受数据
      * Object ()
      * @async
@@ -34,10 +27,10 @@ export declare namespace UtilCom {
      * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
      * @param {number} [repeatCount]    - 重试次数
      * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PostProc} [procFunc]     - 判断有效性函数
-     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
      */
-    function shttpsRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, procFunc?: PostProc): Promise<JObject | null>;
+    function shttpsRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, verifyFn?: PromiseVerifyFn<JObject | null>): Promise<JObject | null>;
     /**重复一个 http POST请求并接受数据
      * Object ()
      * @async
@@ -46,8 +39,8 @@ export declare namespace UtilCom {
      * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
      * @param {number} [repeatCount]    - 重试次数
      * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PostProc} [procFunc]     - 判断有效性函数
-     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
      */
-    function shttpRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, procFunc?: PostProc): Promise<JObject | null>;
+    function shttpRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, verifyFn?: PromiseVerifyFn<JObject | null>): Promise<JObject | null>;
 }

package/dist/UtilCom.js

@@ -14,7 +14,7 @@ var UtilCom;
      * @param {JObject} json 	        - 数据对象
      * @param {Object} options          - 参数对象
      * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
-     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
      */
     function sPost(posttype, json, options, timeLimit = -1) {
         //转换为毫秒
@@ -95,7 +95,7 @@ var UtilCom;
      * @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);
@@ -107,7 +107,7 @@ var UtilCom;
      * @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);
@@ -121,84 +121,12 @@ var UtilCom;
      * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
      * @param {number} [repeatCount]    - 重试次数
      * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PostProc} [procFunc]     - 判断有效性函数
-     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
      */
-    async function sRepeatPost(posttype, json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, procFunc) {
-        //转换为毫秒
-        const hasRepeatTime = (repeatTime >= 10);
-        if (hasRepeatTime)
-            repeatTime *= 1000;
-        //验证处理函数
-        if (procFunc === undefined)
-            procFunc = () => "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(UtilFunctions_1.UtilFunc.getNeverResolvedPromise());
-        for (let i = 0; i < repeatCount;) {
-            UtilLogger_1.SLogger.info("开始第 " + (i + 1) + " 次 sRepeatPost");
-            //创建当前任务
-            plist[i] = sPost(posttype, json, options, timeLimit)
-                .then(result => ({ result, stat: procFunc(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)} 次 sRepeatPost 超时 ${repeatTime} ms 开始重试`);
-                clearTimer();
-                i++;
-                continue;
-            }
-            else {
-                const poststat = await currObj.stat;
-                switch (poststat) {
-                    case "Completed": //完成
-                        UtilLogger_1.SLogger.info("第 " + (currObj.index + 1) + " 次 sRepeatPost 成功");
-                        clearTimer();
-                        return currObj.result;
-                    case "Terminated": //终止
-                        UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 sRepeatPost 终止 停止重试");
-                        clearTimer();
-                        return currObj.result;
-                    case "Failed": //验证失败
-                        //是当前
-                        if (currObj.index == i) {
-                            UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 sRepeatPost 失败 开始重试");
-                            clearTimer();
-                            i++;
-                            continue;
-                        }
-                        //非当前
-                        UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 sRepeatPost 失败");
-                        //抛弃失败
-                        plist[currObj.index] = UtilFunctions_1.UtilFunc.getNeverResolvedPromise();
-                        continue;
-                }
-            }
-        }
-        clearTimer();
-        //全部失败或超时则返回null
-        return 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 ()
@@ -208,11 +136,11 @@ var UtilCom;
      * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
      * @param {number} [repeatCount]    - 重试次数
      * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PostProc} [procFunc]     - 判断有效性函数
-     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
      */
-    function shttpsRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, procFunc) {
-        return sRepeatPost("https", json, options, timeLimit, repeatCount, repeatTime, procFunc);
+    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请求并接受数据
@@ -223,11 +151,11 @@ var UtilCom;
      * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
      * @param {number} [repeatCount]    - 重试次数
      * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PostProc} [procFunc]     - 判断有效性函数
-     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
+     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
      */
-    function shttpRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, procFunc) {
-        return sRepeatPost("http", json, options, timeLimit, repeatCount, repeatTime, procFunc);
+    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.44",
+  "version": "1.0.45",
   "description": "my utils",
   "main": "index.js",
   "scripts": {

package/src/UtilCom.ts

@@ -1,4 +1,4 @@
-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";
@@ -13,7 +13,7 @@ export namespace UtilCom{
  * @param {JObject} json 	        - 数据对象
  * @param {Object} options          - 参数对象
  * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
- * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+ * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
  */
 function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
     //转换为毫秒
@@ -102,7 +102,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
  * @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);
@@ -114,28 +114,13 @@ export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Prom
  * @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);
 }
 
-/**进行中的请求 */
-type ProcessingPost = {
-    /**主体请求 */
-    result:JObject|null;
-    /**请求状态 */
-    stat:PostStat|Promise<PostStat>;
-    /**请求下标/序号 */
-    index:number;
-}
-/**请求完成状态 成功/失败/终止  
- * 成功/终止 将直接返回  
- * 失败 将重试  
- */
-export type PostStat = "Completed"|"Failed"|"Terminated";
-/**post处理函数 */
-export type PostProc = (respObj:JObject|null)=>Promise<PostStat>|PostStat;
+
 
 /**通用重复post处理  
  * @async
@@ -145,88 +130,13 @@ export type PostProc = (respObj:JObject|null)=>Promise<PostStat>|PostStat;
  * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
  * @param {number} [repeatCount]    - 重试次数
  * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
- * @param {PostProc} [procFunc]     - 判断有效性函数
- * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+ * @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,procFunc?:PostProc):Promise<JObject|null>{
-    //转换为毫秒
-    const hasRepeatTime = (repeatTime>=10);
-    if(hasRepeatTime) repeatTime*=1000;
-
-    //验证处理函数
-    if(procFunc===undefined)
-        procFunc = ()=>"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<ProcessingPost>[] = new Array(repeatCount).fill(UtilFunc.getNeverResolvedPromise());
-    for(let i=0;i<repeatCount;){
-        SLogger.info("开始第 "+(i+1)+" 次 sRepeatPost");
-        //创建当前任务
-        plist[i] = sPost(posttype,json,options,timeLimit)
-            .then(result => ({result, stat:procFunc!(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)} 次 sRepeatPost 超时 ${repeatTime} ms 开始重试`);
-            clearTimer(); i++;
-            continue;
-        }else{
-            const poststat = await currObj.stat;
-            switch(poststat){
-                case "Completed"://完成
-                    SLogger.info("第 "+(currObj.index+1)+" 次 sRepeatPost 成功");
-                    clearTimer();
-                    return currObj.result;
-                case "Terminated"://终止
-                    SLogger.warn("第 "+(currObj.index+1)+" 次 sRepeatPost 终止 停止重试");
-                    clearTimer();
-                    return currObj.result;
-                case "Failed"://验证失败
-                    //是当前
-                    if(currObj.index==i){
-                        SLogger.warn("第 "+(currObj.index+1)+" 次 sRepeatPost 失败 开始重试");
-                        clearTimer(); i++;
-                        continue;
-                    }
-                    //非当前
-                    SLogger.warn("第 "+(currObj.index+1)+" 次 sRepeatPost 失败");
-                    //抛弃失败
-                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
-                    continue;
-            }
-        }
-    }
-    clearTimer();
-    //全部失败或超时则返回null
-    return null;
+    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);
 }
 
 
@@ -238,12 +148,12 @@ async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,t
  * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
  * @param {number} [repeatCount]    - 重试次数
  * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
- * @param {PostProc} [procFunc]     - 判断有效性函数
- * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+ * @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,procFunc?:PostProc):Promise<JObject|null>{
-    return sRepeatPost("https",json,options,timeLimit,repeatCount,repeatTime,procFunc);
+    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
+    return sRepeatPost("https",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
 }
 
 /**重复一个 http POST请求并接受数据  
@@ -254,12 +164,12 @@ export function shttpsRepeatPost(json:JObject,options:Object,timeLimit:number=-1
  * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
  * @param {number} [repeatCount]    - 重试次数
  * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
- * @param {PostProc} [procFunc]     - 判断有效性函数
- * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+ * @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,procFunc?:PostProc):Promise<JObject|null>{
-    return sRepeatPost("http",json,options,timeLimit,repeatCount,repeatTime,procFunc);
+    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>;