@zwa73/utils 1.0.79 → 1.0.81

package/src/UtilFunctions.ts

@@ -1,19 +1,18 @@
 import * as crypto from "crypto";
-import { ComposedClass, ComposedMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Mixinable, Outcome, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
+import { AnyFunc, ComposedClass, ComposedMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, LiteralCheck, Matchable, MatchableFlag, Mixinable, Outcome, PromiseStat, PromiseVerifyFn, UnionToIntersection } from "@src/UtilInterfaces";
 import * as cp from "child_process";
 import { SLogger } from "@src/UtilLogger";
-import { Completed, Failed, None, Terminated, Timeout } from "./UtilSymbol";
-import { match, outcome } from "./QuickFunction";
-import { LogTimeAsync } from "./UtilDecorators";
+import { Completed, Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Terminated, Timeout } from "./UtilSymbol";
+import { DeferAsync, LogTimeAsync } from "./UtilDecorators";
 
 
-type CompleteCome<T> = Outcome<Completed,T>;
-type TimeoutCome<T> = Outcome<Timeout,Promise<T>>;
+type SuccessOut<T> = Outcome<Success,T>;
+type TimeoutOut<T> = Outcome<Timeout,Promise<T>>;
 /**永不完成的Promise单例 */
 const NeverResolvedPromise = new Promise(()=>{});
-/**进行中的请求 */
-type ProcessingPromise<T> = {
-    /**主体请求 */
+/**完成的请求 */
+type PromiseResult<T> = {
+    /**请求结果 */
     result:T;
     /**请求状态 */
     stat:PromiseStat;
@@ -80,24 +79,6 @@ static calcHash(str:string) {
     return crypto.createHash('md5').update(str).digest('hex');
 }
 
-/**深克隆 序列化并反序列化  
- * @template T - JToken类型的泛型
- * @param obj  - 克隆目标
- * @returns 克隆结果
- */
-static deepClone<T extends JToken>(obj: T): T {
-    return JSON.parse(JSON.stringify(obj));
-}
-
-/**是否为安全的数字
- * @param num - 所要检测的数字
- * @returns 是否安全
- */
-static isSafeNumber(num: number): boolean {
-    if (num === undefined || num == null || isNaN(num)) return false;
-    if(typeof num === 'number') return true;
-    return false;
-}
 
 /**等待 timeMs 毫秒  
  * @async
@@ -146,7 +127,7 @@ static getNeverResolvedPromise<T>():Promise<T>{
  * @param procFn      - 发起函数
  * @param verifyFn    - 验证函数
  * @param repeatCount - 重试次数
- * @param repeatTime  - 超时时间/秒  最小为10秒
+ * @param repeatTime  - 超时时间/秒  最小为5秒
  * @returns 结果 null 为全部失败/超时
  */
 @LogTimeAsync("repeatPromise ",true)
@@ -154,18 +135,18 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
     repeatCount:number=3,repeatTime:number=180):Promise<T|null>{
 
     /**是否含有超时时间 */
-    const hasRepeatTime = (repeatTime>=10);
+    const hasRepeatTime = (repeatTime>=5);
     //转换为毫秒
     if(hasRepeatTime) repeatTime*=1000;
 
     //验证处理函数
     if(verifyFn===undefined)
-        verifyFn = ()=>Completed;
+        verifyFn = ()=>Success;
 
     //进行中的请求
 	const plist:Promise<
-        CompleteCome<ProcessingPromise<T>>|
-        TimeoutCome<ProcessingPromise<T>>
+        SuccessOut<PromiseResult<T>>|
+        TimeoutOut<PromiseResult<T>>
     >[] = [];
 
     //开始处理
@@ -176,7 +157,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
 
             //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){
-                plist.push(UtilFunc.timelimitPromise<ProcessingPromise<T>>(async ()=>{
+                plist.push(UtilFunc.timelimitPromise<PromiseResult<T>>(async ()=>{
                     const index = i;
                     const result = await procFn();
                     const stat = await verifyFn!(result);
@@ -192,7 +173,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
                 //解除timeout替换原参数
                 plist[i]=new Promise(async (rslove)=>{
                     const res = await currObj.result;
-                    rslove(outcome(Completed,res));
+                    rslove(UtilFunc.outcome(Success,res));
                 })
                 SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
                 i++;
@@ -201,8 +182,8 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
 
             //路由请求状态
             const postresult = currObj.result;
-            const result = match(postresult.stat,{
-                [Completed](){
+            const result = UtilFunc.matchProc(postresult.stat,{
+                [Success](){
                     SLogger.info(`第 ${postresult.index+1} 次 repeatPromise 成功`);
                     //非当前
                     if(postresult.index!=i)
@@ -245,29 +226,29 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
  * @returns 超时则返回 处理函数委托 完成则返回结果
  */
 static timelimitPromise<T>
-    (func:()=>Promise<T>|T,timeLimit?:number):Promise<CompleteCome<T>|TimeoutCome<T>>{
-    return new Promise<CompleteCome<T>|TimeoutCome<T>>((reslove)=>{
+    (func:()=>Promise<T>|T,timeLimit?:number):Promise<SuccessOut<T>|TimeoutOut<T>>{
+    return new Promise<SuccessOut<T>|TimeoutOut<T>>((reslove)=>{
         let clearTimer:(()=>void)| null = null;
         const procer = (async ()=>await func())();
 
-        const procerP = new Promise<CompleteCome<T>>(async (resolve)=>{
+        const procerP = new Promise<SuccessOut<T>>(async (resolve)=>{
             const res = await procer;
-            resolve(outcome(Completed,res));
+            resolve(UtilFunc.outcome(Success,res));
             if(clearTimer) clearTimer();
         });
 
         const timerP = timeLimit
-            ? new Promise<TimeoutCome<T>>((resolve)=>{
+            ? new Promise<TimeoutOut<T>>((resolve)=>{
                 const timer = setTimeout(()=>
-                    resolve(outcome(Timeout,procer))
+                    resolve(UtilFunc.outcome(Timeout,procer))
                 ,timeLimit);//无限制则无限时间
 
                 clearTimer = ()=>{
-                    resolve(outcome(Timeout,procer))
+                    resolve(UtilFunc.outcome(Timeout,procer))
                     clearInterval(timer)
                 }
-            })
-            : UtilFunc.getNeverResolvedPromise<TimeoutCome<T>>();
+            })//未定义时间限制则无限
+            : UtilFunc.getNeverResolvedPromise<TimeoutOut<T>>();
 
         const result = Promise.race([procerP,timerP]);
         reslove(result);
@@ -346,7 +327,7 @@ static composeMixinable
  * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
  * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
  */
-static mapEntries<T extends Object>
+static mapEntries<T extends object>
     (obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T {
     return Object.entries(obj).reduce((result, [key, value]) => {
         result[key as keyof T] = mapper(key as keyof T, value);
@@ -365,4 +346,162 @@ static stringifyJToken(token:JToken|IJData,space:string|number|null|undefined="\
 	return JSON.stringify(token,null,space);
 }
 
+/**代办表 用于队列处理等待 */
+static pendingMap:Record<Keyable,AnyFunc[]> = {};
+
+/**队列处理  
+ * 等待标签为 flag 的队列  
+ * 直到排在之前的任务全部完成再处理当前Promise  
+ * @param flag - 队列标签
+ * @param task - 任务逻辑
+ * @returns 处理结果
+ */
+static async queueProc<T>(flag:Keyable,task:(()=>Promise<T>)|Promise<T>):Promise<T> {
+    this.pendingMap[flag] = this.pendingMap[flag]??[];
+    const pending = this.pendingMap[flag];
+
+    //尝试解除下个任务的等待
+    const tryRes = function(){
+        const thispd = pending;
+        const resolve = thispd.shift();
+        if(resolve) resolve();
+    }
+
+    //空时直接运行 非空时等待
+    if (pending.length <= 0)
+        pending.push(()=>tryRes());
+    else await new Promise((resolve) => pending.push(resolve));
+
+    try {
+        const result = typeof task === 'function'
+            ? await task()
+            : await task;
+        return result;
+    } catch(e){
+        SLogger.fatal(`queuePromise 出现错误`,e);
+        throw e;
+    }finally {
+        tryRes();
+    }
+}
+
+
+
+/**创建一个Outcome */
+static outcome<K extends Keyable,V> (key:K,value:V):Outcome<K,V>{
+    return {
+        status:key,
+        result:value
+    }
+}
+
+
+/**处理联合值
+ * @param t       - 目标值
+ * @param procObj - 所有可能的id组成的处理函数映射 (status, result)=>any
+ * @returns 任意处理函数的返回值
+ */
+static matchProc<
+    T extends Matchable<Keyable>,
+    P extends UnionToIntersection<
+        { [K in MatchableFlag<T>] :
+            (k:K,v:ExtractOutcome<T,MatchableFlag<K>>['result'])=>unknown }>>
+    (t:T, procObj:P):
+    P extends Record<any,AnyFunc>
+        ? {[K in keyof P]: ReturnType<P[K]>}[keyof P]
+        : never {
+    if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol'){
+        if ((procObj as any)[t])
+            return (procObj as any)[t](t);
+        SLogger.fatal(`matchProc 传入了一个预料之外的值: `,t);
+        throw None;
+    }
+    else{
+        if ((procObj as any)[t.status])
+            return (procObj as any)[t.status](t.status,(t as any).result);
+        SLogger.fatal(`matchProc 传入了一个预料之外的值: `,t);
+        throw None;
+    }
+}
+
+/**根据典型的成功或失败状态运行函数  
+ * @param t - 目标值
+ * @param sucessFunc - 成功则运行的函数 (result)=>any
+ * @param failedFunc - 失败则运行的函数 (result)=>any
+ * @param noneFunc   - 无结果或不匹配时运行的函数 ()=>any
+ * @returns 非成功或失败时返回 None
+ */
+static sucesProc<T extends Matchable<StatusSymbol>,
+    S extends (arg:ExtractOutcome<T,SuccessLike>['result'])=>unknown,
+    F extends (arg:ExtractOutcome<T,FailedLike>['result'])=>unknown =
+        (arg:ExtractOutcome<T,FailedLike>['result'])=>None,
+    N extends ()=>unknown = ()=>None>
+    (t:T,sucessFunc:S,failedFunc?:F,noneFunc?:N):
+    ReturnType<S>|ReturnType<F>|ReturnType<N>{
+    failedFunc = failedFunc ?? (()=>None) as any as F;
+    noneFunc = noneFunc ?? (()=>None) as N;
+    const val = typeof t === 'symbol' ? undefined : t.result;
+    if(UtilFunc.isSuccess(t)) return sucessFunc(val) as any;
+    if(UtilFunc.isFailed(t)) return failedFunc(val) as any;
+    if(t!==None) SLogger.warn(`sucesProc 传入了一个不匹配的值, 将作为None运行: `,t);
+    return noneFunc() as any;
+}
+/**是失败的 */
+static isFailed<T>
+    (tg:T):T extends Matchable<FailedLike>
+        ? true : MatchableFlag<T> extends Exclude<MatchableFlag<T>,FailedLike>
+            ? false : boolean{
+    const test = (t:any)=>t === Failed || t === Terminated || t === Timeout;
+    if(tg!=null && typeof tg === 'object' && 'status' in tg)
+        return test(tg.status) as any
+    return test(tg) as any
+}
+
+/**是成功的 */
+static isSuccess<T>
+(tg:T):T extends Matchable<SuccessLike>
+    ? true: MatchableFlag<T> extends Exclude<MatchableFlag<T>,SuccessLike>
+        ? false : boolean{
+    const test = (t:any)=>t === Success || t === Completed;
+    if(tg!=null && typeof tg === 'object' && 'status' in tg)
+        return test(tg.status) as any
+    return test(tg) as any
+}
+
+/**验证一个变量的类型是否为 T
+ * @template T - 验证类型
+ * @param t    - 验证目标
+ */
+static assertType<T>(t:T):T{return t;}
+/**验证一个变量的类型是否为字面量  
+ * 仅限浅层  
+ * @template T - 验证类型
+ * @param t    - 验证目标
+ */
+static assertLiteral<T>(t:LiteralCheck<T>):T{return t as T;}
+
+/**深克隆 序列化并反序列化  
+ * @template T - JToken类型的泛型
+ * @param obj  - 克隆目标
+ * @returns 克隆结果
+ */
+static deepClone<T extends JToken>(obj: T): T {
+    return JSON.parse(JSON.stringify(obj));
+}
+
+/**是否为安全的数字  
+ * 非NaN 非null/undefined  
+ * 且是数字  
+ * @param num - 所要检测的数字
+ * @returns 是否安全
+ */
+static isSafeNumber(num: unknown): boolean {
+    if (num == null) return false;
+    if(typeof num === 'number') {
+        if(isNaN(num)) return false;
+        return true;
+    }
+    return false;
+}
+
 }

package/src/UtilInterfaces.ts

@@ -1,4 +1,4 @@
-import { Completed, Failed, Terminated } from "./UtilSymbol";
+import { Failed, Success, Terminated } from "./UtilSymbol";
 
 
 /**可以序列化为JSON文件的对象 */
@@ -17,10 +17,25 @@ export interface IJData{
 	 */
 	toJSON():JToken;
 }
+/**任何可能有ReturnType的函数 */
+export type AnyFunc = (...args:any)=>any;
 
 /**任意可作为键值的类型 */
 export type Keyable = string | number | symbol;
 
+/**真子集 */
+export type ProperSubset<B, T = B> = T extends B ? B extends T ? never : T : never;
+
+/**字面量检测 */
+export type LiteralCheck<L> =
+    ProperSubset<string, L> |
+    ProperSubset<number, L> |
+    ProperSubset<boolean, L>|
+    ProperSubset<symbol, L> |
+    ProperSubset<any[], L> |
+    ProperSubset<Record<any,any>, L> |
+    null | undefined;
+
 /**转为可写的 */
 export type Writeable<T> = {
 	-readonly [P in keyof T]: T[P]
@@ -40,7 +55,16 @@ export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> =
  */
 export type AnyString = (string&{});
 
-
+/**联合类型转为交叉类型  
+ * 将联合类型映射为联合函数  
+ * 再取得可以传递给任意联合函数的类型  
+ */
+export type UnionToIntersection<U> =
+    (U extends any
+        ? (k: U)=>void
+        : never) extends ((k: infer I)=>void)
+            ? I
+            : never
 
 /**创建一个新的类型，这个新的类型包含了基础类型 B 的所有属性，
  * 以及一个名为 K[N] 类型为 T 的新属性。
@@ -71,13 +95,17 @@ export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string
  * 终止 将直接返回  null  
  * 失败 将重试  
  */
-export type PromiseStat = Completed|Failed|Terminated;
+export type PromiseStat = Success|Failed|Terminated;
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj:T)=>Promise<PromiseStat>|PromiseStat;
 
+/**获取Promise的结果类型 */
+export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+
+
 /**类型中任意函数的字符串名称 */
 export type FuncPropNames<T> = {
-    [K in keyof T]: T[K] extends (...args: unknown[]) => unknown ? K : never;
+    [K in keyof T]: T[K] extends AnyFunc ? K : never;
 }[keyof T];
 
 /**部分组合的类 
@@ -115,20 +143,23 @@ export type ComposedMixinable<B, Ms extends unknown[]> =
  * @template N - 如果为假的返回值
  */
 export type ExtendThen<B,T,Y,N = never> = B extends T ? Y : N;
-/** 一个联合类型 B 中如果包含 T  
+/** 一个联合类型 B 中如果包含 联合类型 T 中的任意项  
+ * 无效  
  * @template B - 基础类型
  * @template T - 判断的目标类型
  * @template Y - 如果为真的返回值
  * @template N - 如果为假的返回值
  */
-export type UnionInclude<B,T,Y,N = never> =
+type UnionInclude<B,T,Y,N = never> =
     B extends Exclude<B,T>
-        ? Y
-        : N
+        ? N
+        : Y
 /**排除可选字段 */
 export type RequiredOnly<T> = {
     [K in keyof T as
-        UnionInclude<T[K],undefined,never,K>
+        T[K] extends Exclude<T[K],undefined>
+            ? K
+            : never
     ]: T[K]
 };
 /**添加前缀 */
@@ -145,12 +176,23 @@ export type WithPrefix<T,P extends string> = {
  */
 export type Outcome<K extends Keyable,V> = {
     /**状态类型 */
-    status:K;
+    readonly status:K;
     /**值 */
-    result:V;
+    readonly result:V;
 }
 
-/**从联合 Outcome 中 根据 id 提取对应 value 的 type */
+/**可进行匹配的 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 */
 export type ExtractOutcome<T,K extends Keyable> =
-    T extends Outcome<K,unknown> ? T : never;
+    T extends Outcome<infer O,unknown>
+        ? O extends Exclude<O,K>
+            ? never
+            : T
+        : never;
 

package/src/UtilSymbol.ts

@@ -1,15 +1,42 @@
-/**完成 */
-export const Completed = Symbol("Completed");
-export type Completed = typeof Completed;
-/**失败 */
+import { Outcome } from "./UtilInterfaces";
+
+
+/**成功 经过验证的结果 */
+export const Success = Symbol("Success");
+export type Success = typeof Success;
+/**失败 可重试的 */
 export const Failed = Symbol("Failed");
 export type Failed = typeof Failed;
-/**终止 */
-export const Terminated = Symbol("Terminated");
-export type Terminated = typeof Terminated;
-/**不存在 */
+/**不存在 无 */
 export const None = Symbol("None");
 export type None = typeof None;
-/**超时 */
+/**完成 未经验证/未超时的结果  
+ * Success扩展  
+ * 仅在Success同时出现时使用
+ */
+export const Completed = Symbol("Completed");
+export type Completed = typeof Completed;
+/**终止 熔断运行  
+ * Failed扩展  
+ * 仅在Failed同时出现时使用
+ */
+export const Terminated = Symbol("Terminated");
+export type Terminated = typeof Terminated;
+/**超时 超时类型的失败  
+ * Failed扩展  
+ * 仅在超时时使用  
+ */
 export const Timeout = Symbol("Timeout");
-export type Timeout = typeof Timeout;
+export type Timeout = typeof Timeout;
+/**失败及其拓展 */
+export type FailedLike = Failed|Timeout|Terminated;
+/**成功及其拓展 */
+export type SuccessLike = Success|Completed;
+/**任意状态标识符 */
+export type StatusSymbol = FailedLike|SuccessLike|None;
+/**结果为 None 的 Outcome */
+export type NoneOut = Outcome<None,None>;
+export const NoneOut = {
+    status:None,
+    result:None,
+} as const as NoneOut;

package/src/test/repeatTest.ts

@@ -1,4 +1,4 @@
-import { Completed, Failed, PromiseStat, PromiseVerifyFn, UtilFunc } from "..";
+import { Failed, PromiseStat, PromiseVerifyFn, Success, UtilFunc } from "..";
 
 // 模拟的异步函数，有一定几率失败
 async function mockAsyncFunction(): Promise<string> {
@@ -11,7 +11,7 @@ async function mockAsyncFunction(): Promise<string> {
 
 // 验证函数，只有当结果为 "Success" 时才认为成功
 function mockVerifyFunction(result: string): PromiseStat {
-    return result === "Success" ? Completed : Failed;
+    return result === "Success" ? Success : Failed;
 }
 
 // 测试 repeatPromise 函数

package/test.bat

@@ -1,2 +1,2 @@
-node test
+call npm run test
 pause

package/tsconfig.compile.json

@@ -0,0 +1,4 @@
+{
+    "extends": "./tsconfig.json",
+    "include": ["./src/**/*.ts", "./src/**/*.js"]
+}

package/tsconfig.json

@@ -11,9 +11,10 @@
     "experimentalDecorators": true,
     "paths": {
       "@src/*": ["./src/*"],
-      "@*"    : ["./*"]
+      "@/*"   : ["./*"],
+      "@"     : ["./src/index"]
     }
   },
-  "include": ["./src/**/*.ts", "./src/**/*.js"],
+  "include": ["./src/**/*.ts", "./src/**/*.js","./jest/**/*.ts"],
   "exclude": ["./node_modules/**/*"]
 }

package/watch.bat

@@ -0,0 +1 @@
+npm run watch

package/test/test.bat

@@ -1,2 +0,0 @@
-node test.js
-pause

package/testAndCompile.bat

@@ -1,4 +0,0 @@
-call tsc
-call tsc-alias
-node test
-pause

package/tsCompile.bat

@@ -1,3 +0,0 @@
-call tsc
-call tsc-alias
-pause

package/tsCompileWatch.bat

@@ -1,2 +0,0 @@
-start tsc-alias -w
-start tsc -w