@zwa73/utils 1.0.128 → 1.0.130

package/dist/UtilCom.d.ts

@@ -1,4 +1,9 @@
 import { JObject, ReqVerifyFn } from "./UtilInterfaces";
+import { RepeatPromiseOpt } from "./UtilFunctions";
+type RepeatPostOpt = Partial<{
+    /**httppost 超时中断时间限制 */
+    post_timelimit?: number;
+}> & RepeatPromiseOpt;
 /**网络工具 */
 export declare namespace UtilCom {
     /**发送一个 https POST请求并接受数据
@@ -19,25 +24,30 @@ export declare namespace UtilCom {
     function shttpPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
     /**重复一个 https POST请求并接受数据
      * @async
-     * @param json 	      - 数据对象
-     * @param options     - 参数对象
-     * @param timeLimit   - 超时时间/秒  最小为10秒
-     * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为10秒
-     * @param verifyFn    - 判断有效性函数
+     * @param json 	   - 数据对象
+     * @param options  - 参数对象
+     * @param verifyFn - 判断有效性函数
+     * @param opt      - 可选参数
+     * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
+     * @param opt.count          - 重试次数 默认3
+     * @param opt.try_interval   - 重试超时时间/秒  最小为5秒 默认180
+     * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, verifyFn?: ReqVerifyFn<JObject | null>): Promise<JObject | null>;
+    function shttpsRepeatPost(json: JObject, options: Object, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<JObject | null>;
     /**重复一个 http POST请求并接受数据
      * Object ()
      * @async
-     * @param json 	      - 数据对象
-     * @param options     - 参数对象
-     * @param timeLimit   - 超时时间/秒  最小为10秒
-     * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为10秒
-     * @param verifyFn    - 判断有效性函数
+     * @param json 	   - 数据对象
+     * @param options  - 参数对象
+     * @param verifyFn - 判断有效性函数
+     * @param opt      - 可选参数
+     * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
+     * @param opt.count          - 重试次数 默认3
+     * @param opt.try_interval   - 重试超时时间/秒  最小为5秒 默认180
+     * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, verifyFn?: ReqVerifyFn<JObject | null>): Promise<JObject | null>;
+    function shttpRepeatPost(json: JObject, options: Object, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<JObject | null>;
 }
+export {};

package/dist/UtilCom.js

@@ -38,11 +38,12 @@ var UtilCom;
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function sPost(posttype, json, options, timeLimit = -1) {
+    function sPost(posttype, json, options, timeLimit) {
         //转换为毫秒
-        const hasTimeLimit = (timeLimit >= 10);
-        if (hasTimeLimit)
+        const hasTimeLimit = (timeLimit ? timeLimit >= 10 : false);
+        if (hasTimeLimit && timeLimit != undefined)
             timeLimit *= 1000;
+        const fixlimit = timeLimit;
         const jsonStr = UtilFunctions_1.UtilFunc.stringifyJToken(json);
         const funcName = `s${posttype}Psot`;
         return new Promise((resolve, rejecte) => {
@@ -50,7 +51,7 @@ var UtilCom;
                 try {
                     //请求超时
                     if (hasTimeLimit) {
-                        res.setTimeout(timeLimit, () => {
+                        res.setTimeout(fixlimit, () => {
                             //res.abort();
                             UtilLogger_1.SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
                             resolve(null);
@@ -98,7 +99,7 @@ var UtilCom;
                 req = http.request(options, resFunc);
             //请求超时
             if (hasTimeLimit) {
-                req.setTimeout(timeLimit, () => {
+                req.setTimeout(fixlimit, () => {
                     UtilLogger_1.SLogger.warn(`${funcName} 发送请求超时: ${timeLimit} ms`);
                     req.destroy();
                 });
@@ -118,7 +119,7 @@ var UtilCom;
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsPost(json, options, timeLimit = -1) {
+    function shttpsPost(json, options, timeLimit) {
         return sPost("https", json, options, timeLimit);
     }
     UtilCom.shttpsPost = shttpsPost;
@@ -129,52 +130,61 @@ var UtilCom;
      * @param timeLimit - 超时时间/秒  最小为10秒
      * @returns 结果 null 为未能成功接收
      */
-    function shttpPost(json, options, timeLimit = -1) {
+    function shttpPost(json, options, timeLimit) {
         return sPost("http", json, options, timeLimit);
     }
     UtilCom.shttpPost = shttpPost;
     /**通用重复post处理
      * @async
-     * @param posttype    - post类型
-     * @param json 	      - 数据对象
-     * @param options     - 参数对象
-     * @param timeLimit   - 超时时间/秒  最小为10秒
-     * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为10秒
-     * @param verifyFn    - 判断有效性函数
+     * @param posttype - post类型
+     * @param json 	   - 数据对象
+     * @param options  - 参数对象
+     * @param verifyFn - 判断有效性函数
+     * @param opt      - 可选参数
+     * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
+     * @param opt.count          - 重试次数 默认3
+     * @param opt.try_interval   - 重试超时时间/秒  最小为5秒 默认180
+     * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 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);
+    async function sRepeatPost(posttype, json, options, verifyFn, opt = {}) {
+        opt.count = opt.count ?? 3;
+        opt.try_interval = opt.try_interval ?? 180;
+        opt.try_delay = opt.try_delay ?? 1;
+        const procFn = () => sPost(posttype, json, options, opt.post_timelimit);
+        return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, opt);
     }
     /**重复一个 https POST请求并接受数据
      * @async
-     * @param json 	      - 数据对象
-     * @param options     - 参数对象
-     * @param timeLimit   - 超时时间/秒  最小为10秒
-     * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为10秒
-     * @param verifyFn    - 判断有效性函数
+     * @param json 	   - 数据对象
+     * @param options  - 参数对象
+     * @param verifyFn - 判断有效性函数
+     * @param opt      - 可选参数
+     * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
+     * @param opt.count          - 重试次数 默认3
+     * @param opt.try_interval   - 重试超时时间/秒  最小为5秒 默认180
+     * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpsRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, verifyFn) {
-        return sRepeatPost("https", json, options, timeLimit, repeatCount, repeatTime, verifyFn);
+    function shttpsRepeatPost(json, options, verifyFn, opt) {
+        return sRepeatPost("https", json, options, verifyFn, opt);
     }
     UtilCom.shttpsRepeatPost = shttpsRepeatPost;
     /**重复一个 http POST请求并接受数据
      * Object ()
      * @async
-     * @param json 	      - 数据对象
-     * @param options     - 参数对象
-     * @param timeLimit   - 超时时间/秒  最小为10秒
-     * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为10秒
-     * @param verifyFn    - 判断有效性函数
+     * @param json 	   - 数据对象
+     * @param options  - 参数对象
+     * @param verifyFn - 判断有效性函数
+     * @param opt      - 可选参数
+     * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
+     * @param opt.count          - 重试次数 默认3
+     * @param opt.try_interval   - 重试超时时间/秒  最小为5秒 默认180
+     * @param opt.try_delay      - 重试间隔 秒 默认0
      * @returns 结果 null 为未能成功接收
      */
-    function shttpRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, verifyFn) {
-        return sRepeatPost("http", json, options, timeLimit, repeatCount, repeatTime, verifyFn);
+    function shttpRepeatPost(json, options, verifyFn, opt) {
+        return sRepeatPost("http", json, options, verifyFn, opt);
     }
     UtilCom.shttpRepeatPost = shttpRepeatPost;
 })(UtilCom || (exports.UtilCom = UtilCom = {}));

package/dist/UtilFunctions.d.ts

@@ -8,6 +8,17 @@ type ExecOpt = Partial<{
     outlvl: LogLevel;
     errlvl: LogLevel;
 }>;
+/**Promise重试选项 */
+export type RepeatPromiseOpt = Partial<{
+    /**重试次数 默认3*/
+    count?: number;
+    /**尝试间隔时间 超过此事件会重新创建新的Promise
+     * 同时等待新的与旧的Promise 秒 默认180
+     */
+    try_interval?: number;
+    /**尝试延迟 重新尝试时会先等待此秒数 秒 默认0*/
+    try_delay?: number;
+}>;
 type SuccessOut<T> = Outcome<Success, T>;
 type TimeoutOut<T> = Outcome<Timeout, Promise<T>>;
 /**常用函数 */
@@ -75,11 +86,13 @@ export declare class UtilFunc {
      * @async
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
-     * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为5秒
+     * @param opt         - 可选参数
+     * @param opt.count    - 重试次数 默认3
+     * @param opt.timeout  - 超时时间/秒  默认180 最小为5秒
+     * @param opt.interval - 重试间隔时间 默认0
      * @returns 结果 null 为全部失败/超时
      */
-    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: ReqVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
+    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: ReqVerifyFn<T>, opt?: RepeatPromiseOpt): Promise<T | null>;
     /**创建一个限时的Promise
      * @param func      - 处理函数
      * @param timeLimit - 毫秒限时

package/dist/UtilFunctions.js

@@ -166,16 +166,21 @@ class UtilFunc {
      * @async
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
-     * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为5秒
+     * @param opt         - 可选参数
+     * @param opt.count    - 重试次数 默认3
+     * @param opt.timeout  - 超时时间/秒  默认180 最小为5秒
+     * @param opt.interval - 重试间隔时间 默认0
      * @returns 结果 null 为全部失败/超时
      */
-    static async repeatPromise(procFn, verifyFn, repeatCount = 3, repeatTime = 180) {
+    static async repeatPromise(procFn, verifyFn, opt = {}) {
+        opt.count = opt.count ?? 3;
+        opt.try_interval = opt.try_interval ?? 180;
+        let { count, try_interval } = opt;
         /**是否含有超时时间 */
-        const hasRepeatTime = (repeatTime >= 5);
+        const hasRepeatTime = (try_interval >= 5);
         //转换为毫秒
         if (hasRepeatTime)
-            repeatTime *= 1000;
+            try_interval *= 1000;
         //验证处理函数
         if (verifyFn === undefined)
             verifyFn = () => UtilSymbol_1.Success;
@@ -184,7 +189,9 @@ class UtilFunc {
         //开始处理
         try {
             //根据最大重试次数限制进行循环
-            for (let i = 0; i < repeatCount;) {
+            for (let i = 0; i < count;) {
+                if (i > 0 && opt.try_delay)
+                    await this.sleep(opt.try_delay * 1000);
                 UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 repeatPromise`);
                 //如果 plist 中当前下标的任务还未创建 则 创建当前任务
                 if (plist.length < i + 1) {
@@ -193,7 +200,7 @@ class UtilFunc {
                         const result = await procFn();
                         const stat = await verifyFn(result);
                         return { result, stat, index };
-                    }, hasRepeatTime ? repeatTime : undefined));
+                    }, hasRepeatTime ? try_interval : undefined));
                 }
                 //等待任意任务 或当前计时器完成
                 const currObj = await Promise.race([...plist]);
@@ -204,7 +211,7 @@ class UtilFunc {
                         const res = await currObj.result;
                         rslove(UtilFunc.outcome(UtilSymbol_1.Success, res));
                     });
-                    UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
+                    UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 repeatPromise 超时 ${try_interval} ms 开始重试`);
                     i++;
                     continue;
                 }
@@ -215,7 +222,7 @@ class UtilFunc {
                         UtilLogger_1.SLogger.info(`第 ${postresult.index + 1} 次 repeatPromise 成功`);
                         //非当前
                         if (postresult.index != i)
-                            UtilLogger_1.SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
+                            UtilLogger_1.SLogger.info(`成功的 promise 非当前 promise 考虑增大重试时间\n当前index: ${i}\n当前重试时间: ${try_interval}`);
                         return postresult.result;
                     },
                     [UtilSymbol_1.Terminated]() {
@@ -240,7 +247,7 @@ class UtilFunc {
                     return result;
             }
             //全部失败或超时则返回null
-            UtilLogger_1.SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
+            UtilLogger_1.SLogger.warn(`${count} 次 repeatPromise 尝试均失败`);
             return null;
         }
         catch (err) {
@@ -681,6 +688,6 @@ exports.UtilFunc = UtilFunc;
 __decorate([
     (0, UtilDecorators_1.LogTimeAsync)("repeatPromise ", true),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Function, Function, Number, Number]),
+    __metadata("design:paramtypes", [Function, Function, Object]),
     __metadata("design:returntype", Promise)
 ], UtilFunc, "repeatPromise", null);

package/dist/UtilInterfaces.d.ts

@@ -68,10 +68,10 @@ export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> = R[
  */
 export type AnyString = (string & {});
 /**联合类型转为交叉类型
- * 将联合类型映射为联合函数
- * 再取得可以传递给任意联合函数的类型
+ * 利用分布式条件将U展开为联合函数(k:U1)=>void | (k:U2)=>void
+ * 再从中提取可以传递给任意联合函数的类型
  */
-export type UnionToIntersection<U> = ((k: U) => void) extends ((k: infer I) => void) ? I : never;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /**创建一个新的类型，这个新的类型包含了基础类型 B 的所有属性，
  * 以及一个名为 K[N] 类型为 T 的新属性。
  * 所有 K 中非 K[N] 的其他属性都是可选的并且不能被赋值（因为它们的类型是 never）。

package/package.json

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

package/src/UtilCom.ts

@@ -2,9 +2,15 @@ import { JObject, ReqVerifyFn } from "@src/UtilInterfaces";
 import * as https from 'https';
 import * as http from 'http';
 import { SLogger } from "@src/UtilLogger";
-import { UtilFunc } from "@src/UtilFunctions";
+import { RepeatPromiseOpt, UtilFunc } from "@src/UtilFunctions";
 
 
+
+type RepeatPostOpt = Partial<{
+    /**httppost 超时中断时间限制 */
+    post_timelimit?   : number;
+}> & RepeatPromiseOpt;
+
 /**网络工具 */
 export namespace UtilCom{
 
@@ -15,11 +21,11 @@ export namespace UtilCom{
  * @param timeLimit - 超时时间/秒  最小为10秒
  * @returns 结果 null 为未能成功接收
  */
-function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
+function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit?:number):Promise<JObject|null>{
     //转换为毫秒
-    const hasTimeLimit = (timeLimit>=10);
-    if(hasTimeLimit)
-        timeLimit*=1000
+    const hasTimeLimit = (timeLimit ? timeLimit>=10 : false );
+    if(hasTimeLimit && timeLimit!=undefined) timeLimit*=1000;
+    const fixlimit = timeLimit as number;
 
     const jsonStr = UtilFunc.stringifyJToken(json);
     const funcName = `s${posttype}Psot`;
@@ -29,7 +35,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
             try{
                 //请求超时
                 if(hasTimeLimit){
-                    res.setTimeout(timeLimit, ()=>{
+                    res.setTimeout(fixlimit, ()=>{
                         //res.abort();
                         SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
                         resolve(null);
@@ -80,7 +86,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
 
         //请求超时
         if(hasTimeLimit){
-            req.setTimeout(timeLimit, ()=>{
+            req.setTimeout(fixlimit, ()=>{
                 SLogger.warn(`${funcName} 发送请求超时: ${timeLimit} ms`);
                 req.destroy();
             });
@@ -103,7 +109,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
  * @param timeLimit - 超时时间/秒  最小为10秒
  * @returns 结果 null 为未能成功接收
  */
-export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
+export function shttpsPost(json:JObject,options:Object,timeLimit?:number):Promise<JObject|null>{
     return sPost("https",json,options,timeLimit);
 }
 
@@ -114,7 +120,7 @@ export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Prom
  * @param timeLimit - 超时时间/秒  最小为10秒
  * @returns 结果 null 为未能成功接收
  */
-export function shttpPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
+export function shttpPost(json:JObject,options:Object,timeLimit?:number):Promise<JObject|null>{
     return sPost("http",json,options,timeLimit);
 }
 
@@ -122,51 +128,58 @@ export function shttpPost(json:JObject,options:Object,timeLimit:number=-1):Promi
 
 /**通用重复post处理  
  * @async
- * @param posttype    - post类型
- * @param json 	      - 数据对象
- * @param options     - 参数对象
- * @param timeLimit   - 超时时间/秒  最小为10秒
- * @param repeatCount - 重试次数
- * @param repeatTime  - 超时时间/秒  最小为10秒
- * @param verifyFn    - 判断有效性函数
+ * @param posttype - post类型
+ * @param json 	   - 数据对象
+ * @param options  - 参数对象
+ * @param verifyFn - 判断有效性函数
+ * @param opt      - 可选参数
+ * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
+ * @param opt.count          - 重试次数 默认3
+ * @param opt.try_interval   - 重试超时时间/秒  最小为5秒 默认180
+ * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1,
-    repeatCount:number=3,repeatTime:number=180,verifyFn?:ReqVerifyFn<JObject|null>):Promise<JObject|null>{
-    const procFn = ()=>sPost(posttype,json,options,timeLimit);
-    return UtilFunc.repeatPromise(procFn,verifyFn,repeatCount,repeatTime);
+async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,verifyFn?:ReqVerifyFn<JObject|null>,opt:RepeatPostOpt={}):Promise<JObject|null>{
+    opt.count        = opt.count??3;
+    opt.try_interval = opt.try_interval??180;
+    opt.try_delay    = opt.try_delay??1;
+
+    const procFn = ()=>sPost(posttype,json,options,opt.post_timelimit);
+    return UtilFunc.repeatPromise(procFn,verifyFn,opt);
 }
 
 
 /**重复一个 https POST请求并接受数据  
  * @async
- * @param json 	      - 数据对象
- * @param options     - 参数对象
- * @param timeLimit   - 超时时间/秒  最小为10秒
- * @param repeatCount - 重试次数
- * @param repeatTime  - 超时时间/秒  最小为10秒
- * @param verifyFn    - 判断有效性函数
+ * @param json 	   - 数据对象
+ * @param options  - 参数对象
+ * @param verifyFn - 判断有效性函数
+ * @param opt      - 可选参数
+ * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
+ * @param opt.count          - 重试次数 默认3
+ * @param opt.try_interval   - 重试超时时间/秒  最小为5秒 默认180
+ * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-export function shttpsRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
-    repeatCount:number=3,repeatTime:number=180,verifyFn?:ReqVerifyFn<JObject|null>):Promise<JObject|null>{
-    return sRepeatPost("https",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
+export function shttpsRepeatPost(json:JObject,options:Object,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):Promise<JObject|null>{
+    return sRepeatPost("https",json,options,verifyFn,opt);
 }
 
 /**重复一个 http POST请求并接受数据  
  * Object ()  
  * @async
- * @param json 	      - 数据对象
- * @param options     - 参数对象
- * @param timeLimit   - 超时时间/秒  最小为10秒
- * @param repeatCount - 重试次数
- * @param repeatTime  - 超时时间/秒  最小为10秒
- * @param verifyFn    - 判断有效性函数
+ * @param json 	   - 数据对象
+ * @param options  - 参数对象
+ * @param verifyFn - 判断有效性函数
+ * @param opt      - 可选参数
+ * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
+ * @param opt.count          - 重试次数 默认3
+ * @param opt.try_interval   - 重试超时时间/秒  最小为5秒 默认180
+ * @param opt.try_delay      - 重试间隔 秒 默认0
  * @returns 结果 null 为未能成功接收
  */
-export function shttpRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
-    repeatCount:number=3,repeatTime:number=180,verifyFn?:ReqVerifyFn<JObject|null>):Promise<JObject|null>{
-    return sRepeatPost("http",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
+export function shttpRepeatPost(json:JObject,options:Object,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):Promise<JObject|null>{
+    return sRepeatPost("http",json,options,verifyFn,opt);
 }
 
 }

package/src/UtilFunctions.ts

@@ -18,6 +18,18 @@ type ExecOpt = Partial<{
     errlvl:LogLevel,
 }>
 
+/**Promise重试选项 */
+export type RepeatPromiseOpt = Partial<{
+    /**重试次数 默认3*/
+    count?        :number;
+    /**尝试间隔时间 超过此事件会重新创建新的Promise
+     * 同时等待新的与旧的Promise 秒 默认180
+     */
+    try_interval? :number;
+    /**尝试延迟 重新尝试时会先等待此秒数 秒 默认0*/
+    try_delay?    :number;
+}>
+
 type SuccessOut<T> = Outcome<Success,T>;
 type TimeoutOut<T> = Outcome<Timeout,Promise<T>>;
 /**永不完成的Promise单例 */
@@ -178,18 +190,21 @@ static getNeverResolvedPromise<T>():Promise<T>{
  * @async
  * @param procFn      - 发起函数
  * @param verifyFn    - 验证函数
- * @param repeatCount - 重试次数
- * @param repeatTime  - 超时时间/秒  最小为5秒
+ * @param opt         - 可选参数
+ * @param opt.count    - 重试次数 默认3
+ * @param opt.timeout  - 超时时间/秒  默认180 最小为5秒
+ * @param opt.interval - 重试间隔时间 默认0
  * @returns 结果 null 为全部失败/超时
  */
 @LogTimeAsync("repeatPromise ",true)
-static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,
-    repeatCount:number=3,repeatTime:number=180):Promise<T|null>{
-
+static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,opt:RepeatPromiseOpt = {}):Promise<T|null>{
+    opt.count = opt.count??3;
+    opt.try_interval = opt.try_interval??180;
+    let {count,try_interval} = opt;
     /**是否含有超时时间 */
-    const hasRepeatTime = (repeatTime>=5);
+    const hasRepeatTime = (try_interval>=5);
     //转换为毫秒
-    if(hasRepeatTime) repeatTime*=1000;
+    if(hasRepeatTime) try_interval*=1000;
 
     //验证处理函数
     if(verifyFn===undefined)
@@ -204,9 +219,9 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,
     //开始处理
     try{
         //根据最大重试次数限制进行循环
-        for(let i=0;i<repeatCount;){
+        for(let i=0;i<count;){
+            if(i>0 && opt.try_delay) await this.sleep(opt.try_delay*1000);
             SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
-
             //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){
                 plist.push(UtilFunc.timelimitPromise<PromiseResult<T>>(async ()=>{
@@ -214,7 +229,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,
                     const result = await procFn();
                     const stat = await verifyFn!(result);
                     return {result, stat, index}
-                },hasRepeatTime?repeatTime:undefined));
+                },hasRepeatTime?try_interval:undefined));
             }
 
             //等待任意任务 或当前计时器完成
@@ -227,7 +242,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,
                     const res = await currObj.result;
                     rslove(UtilFunc.outcome(Success,res));
                 })
-                SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
+                SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${try_interval} ms 开始重试`);
                 i++;
                 continue;
             }
@@ -239,7 +254,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,
                     SLogger.info(`第 ${postresult.index+1} 次 repeatPromise 成功`);
                     //非当前
                     if(postresult.index!=i)
-                        SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
+                        SLogger.info(`成功的 promise 非当前 promise 考虑增大重试时间\n当前index: ${i}\n当前重试时间: ${try_interval}`);
                     return postresult.result;
                 },
                 [Terminated](){
@@ -263,7 +278,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,
             if(result !== None) return result;
         }
         //全部失败或超时则返回null
-        SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
+        SLogger.warn(`${count} 次 repeatPromise 尝试均失败`);
         return null;
     }catch(err){
         SLogger.warn(`repeatPromise 发生错误`,err);

package/src/UtilInterfaces.ts

@@ -97,12 +97,15 @@ export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> =
 export type AnyString = (string&{});
 
 /**联合类型转为交叉类型  
- * 将联合类型映射为联合函数  
- * 再取得可以传递给任意联合函数的类型  
+ * 利用分布式条件将U展开为联合函数(k:U1)=>void | (k:U2)=>void  
+ * 再从中提取可以传递给任意联合函数的类型  
  */
 export type UnionToIntersection<U> =
-    ((k: U)=>void) extends ((k: infer I)=>void)
-        ? I : never
+    (U extends any
+        ? (k: U)=>void
+        : never) extends ((k: infer I)=>void)
+            ? I
+            : never
 
 /**创建一个新的类型，这个新的类型包含了基础类型 B 的所有属性，
  * 以及一个名为 K[N] 类型为 T 的新属性。