@zwa73/utils 1.0.198 → 1.0.200

package/src/UtilFunctions.ts

@@ -31,7 +31,7 @@ type StringifyOpt = Partial<{
 }>
 
 /**Promise重试选项 */
-export type RepeatPromiseOpt = Partial<{
+export type PromiseRetries = Partial<{
     /**重试次数 默认3*/
     count?        :number;
     /**尝试间隔时间 超过此事件会重新创建新的Promise
@@ -40,6 +40,10 @@ export type RepeatPromiseOpt = Partial<{
     tryInterval? :number;
     /**尝试延迟 重新尝试时会先等待此毫秒数 毫秒 默认0*/
     tryDelay?    :number;
+    /**是否使用指数回退 默认false 仅在tryDelay被设置时有效 */
+    expBackoff?:boolean;
+    /**指数回退上限值 默认无限*/
+    expBackoffMax?:number;
 }>
 
 type SuccessOut<T> = Outcome<Success,T>;
@@ -57,7 +61,7 @@ type PromiseResult<T> = {
 };
 
 /**完成的重试请求 */
-export type RepeatPromiseResult<T> = {
+export type PromiseRetryResult<T> = {
     completed:T|undefined;
     /**还未完成的其他Promise 若是验证失败则会返回undefined */
     pending:Promise<T|undefined>[];
@@ -222,23 +226,23 @@ static getNeverResolvedPromise<T>():Promise<T>{
 
 /**重复尝试promise  
  * @async
- * @param procFn      - 发起函数
- * @param verifyFn    - 验证函数
- * @param opt         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
+ * @param proc      - 发起函数
+ * @param verify    - 验证函数
+ * @param retries         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
  * @returns 重复结果
  */
-@LogTimeAsync("repeatPromise ",true)
-static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:StatusVerifyFn<T>,opt:RepeatPromiseOpt = {}):
-Promise<RepeatPromiseResult<T>>{
-    opt.count = opt.count??3;
-    opt.tryInterval = opt.tryInterval??180_000;
-    const {count,tryInterval} = opt;
+@LogTimeAsync("retryPromise ",true)
+static async retryPromise<T>(proc:()=>Promise<T>,verify?:StatusVerifyFn<T>,retries:PromiseRetries = {}):
+Promise<PromiseRetryResult<T>>{
+    retries.count = retries.count??3;
+    retries.tryInterval = retries.tryInterval??180_000;
+    const {count,tryInterval,tryDelay} = retries;
     /**是否含有超时时间 */
     const hasRepeatTime = (tryInterval>=5000);
 
     //验证处理函数
-    if(verifyFn===undefined)
-        verifyFn = ()=>Success;
+    if(verify===undefined)
+        verify = ()=>Success;
 
     //进行中的请求
     const plist:Promise<
@@ -250,14 +254,19 @@ Promise<RepeatPromiseResult<T>>{
     try{
         //根据最大重试次数限制进行循环
         for(let i=0;i<count;){
-            if(i>0 && opt.tryDelay) await UtilFunc.sleep(opt.tryDelay);
-            SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
+            if(i>0 && tryDelay){
+                const delay = retries.expBackoff
+                    ? Math.min((Math.pow(2,i)-1)*tryDelay,retries.expBackoffMax??Infinity)
+                    : tryDelay;
+                await UtilFunc.sleep(delay);
+            }
+            SLogger.info(`开始第 ${i+1} 次 retryPromise`);
             //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){
                 plist.push(UtilFunc.timelimitPromise<PromiseResult<T>>(async ()=>{
                     const index = i;
-                    const result = await procFn();
-                    const stat = await verifyFn!(result);
+                    const result = await proc();
+                    const stat = await verify!(result);
                     return {result, stat, index}
                 },hasRepeatTime?tryInterval:undefined));
             }
@@ -272,7 +281,7 @@ Promise<RepeatPromiseResult<T>>{
                     const res = await currObj.result;
                     rslove(UtilFunc.outcome(Success,res));
                 })
-                SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${tryInterval} ms 开始重试`);
+                SLogger.warn(`第 ${i+1} 次 retryPromise 超时 ${tryInterval} ms 开始重试`);
                 i++;
                 continue;
             }
@@ -281,14 +290,14 @@ Promise<RepeatPromiseResult<T>>{
             const postresult = currObj.result;
             const result = UtilFunc.matchProc(postresult.stat,{
                 [Success](){
-                    SLogger.info(`第 ${postresult.index+1} 次 repeatPromise 成功`);
+                    SLogger.info(`第 ${postresult.index+1} 次 retryPromise 成功`);
                     //非当前
                     if(postresult.index!=i)
                         SLogger.info(`成功的 promise 非当前 promise 考虑增大重试时间\n当前index: ${i}\n当前重试时间: ${tryInterval}`);
                     return postresult.result;
                 },
                 [Terminated](){
-                    SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 终止 停止重试`);
+                    SLogger.warn(`第 ${postresult.index+1} 次 retryPromise 终止 停止重试`);
                     return postresult.result;
                 },
                 [Failed]():None{
@@ -296,12 +305,12 @@ Promise<RepeatPromiseResult<T>>{
                     plist[postresult.index] = UtilFunc.getNeverResolvedPromise();
                     //是当前
                     if(postresult.index==i){
-                        SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 失败 开始重试`);
+                        SLogger.warn(`第 ${postresult.index+1} 次 retryPromise 失败 开始重试`);
                         i++;
                         return None;
                     }
                     //非当前
-                    SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 失败`);
+                    SLogger.warn(`第 ${postresult.index+1} 次 retryPromise 失败`);
                     return None;
                 },
             });
@@ -325,7 +334,7 @@ Promise<RepeatPromiseResult<T>>{
             };
         }
         //全部失败或超时则返回 全pending
-        SLogger.warn(`${count} 次 repeatPromise 尝试均失败`);
+        SLogger.warn(`${count} 次 retryPromise 尝试均失败`);
         return {
             completed:undefined,
             pending:plist
@@ -344,7 +353,7 @@ Promise<RepeatPromiseResult<T>>{
                 }),
         };
     }catch(err){
-        SLogger.warn(`repeatPromise 发生意外错误`,err);
+        SLogger.warn(`retryPromise 发生意外错误`,err);
         return {completed:undefined,pending:[]};
     }
 }
@@ -822,10 +831,13 @@ static expect<T>(t:T,errLog?:string):Exclude<T,None>{
  * @param func - 待转换函数
  * @returns 转换完成的函数
  */
-static eitherize<T extends AnyFunc>(func:T) {
+static eitherize<T extends AnyFunc>(
+    func:ReturnType<T> extends Promise<any>
+        ? Error&"对异步函数请使用taskEitherize" : T
+) {
     return (...args: Parameters<T>) => {
         try {
-            const result:ReturnType<T> = func(...args as any);
+            const result:ReturnType<T> = (func as T)(...args as any);
             return UtilFunc.outcome(Success,result);
         } catch (error) {
             if(error instanceof Error)
@@ -841,7 +853,7 @@ static eitherize<T extends AnyFunc>(func:T) {
 static taskEitherize<T extends (...args:any)=>Promise<any>>(func:T) {
     return async (...args: Parameters<T>) => {
         try {
-            const result:Awaited<ReturnType<T>> = await func(...args as any);
+            const result:Awaited<ReturnType<T>> = await func(...args);
             return UtilFunc.outcome(Success,result);
         } catch (error) {
             if(error instanceof Error)

package/src/UtilInterfaces.ts

@@ -193,7 +193,8 @@ export type WithPrefix<T,P extends string> = {
             : K
     ]: T[K]
 };
-/**返回结果  
+
+/**附带状态的返回结果用于状态返回值的封装  
  * @template K - 类型键值
  * @template V - 值
  */
@@ -203,26 +204,23 @@ export type Outcome<K extends Keyable,V> = {
     /**值 */
     readonly result:V;
 }
-/**可成功或失败的结果  
- * @template S - 成功时的结果
- * @template F - 失败时的结果
+/**可进行匹配的对象  
+ * 如果是Outcome则自动处理status  
  */
-export type Eithercome<S,F> =
-    Outcome<Success,S>|Outcome<Failed,F>;
-
-/**可进行匹配的 outcome或symbol */
 export type Matchable<T extends Keyable> = T|Outcome<T,unknown>;
 /**可进行匹配的 outcome或symbol 中的状态类型 */
 export type MatchableFlag<T> =
     T extends infer O|Outcome<infer O,unknown>
         ? O : never;
 
-/**从联合 Outcome 中 根据 id 提取对应 Outcome */
+/**从联合 Outcome 中 根据 K 提取对应 Outcome
+ * @template T - 联合Outcome匹配的类型
+ * @template K - 所需的状态
+*/
 export type ExtractOutcome<T,K extends Keyable> =
     T extends Outcome<infer O,unknown>
         ? O extends Exclude<O,K>
-            ? never
-            : T
+            ? never : T
         : never;
 
 /**用于辅助解析智能补全的类型