@zwa73/utils 1.0.80 → 1.0.82

package/jest.config.js

@@ -0,0 +1,16 @@
+
+
+
+
+module.exports = {
+    roots: ['./jest'],
+    transform: {
+        '^.+\\.tsx?$': 'ts-jest',
+    },
+    moduleNameMapper: {
+        '^@src/(.*)$': '<rootDir>/dist/$1',
+        '^@/(.*)$': '<rootDir>/$1',
+        '^@$': '<rootDir>/index'
+    },
+    moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+};

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@zwa73/utils",
-  "version": "1.0.80",
+  "version": "1.0.82",
   "description": "my utils",
   "main": "index.js",
   "scripts": {
-    "test": "node test",
-    "postinstall": "start node postinstall.js",
-    "release": "call release.bat"
+    "test": "call npm run compile && jest",
+    "postinstall": "start node ./scripts/postinstall.js",
+    "release": "call release.bat",
+    "compile": "call tsc -p tsconfig.compile.json && call tsc-alias -p tsconfig.compile.json",
+    "watch": "start tsc-alias -w -p tsconfig.compile.json && start tsc -w -p tsconfig.compile.json"
   },
   "keywords": [
     "zwa73"
@@ -28,6 +30,11 @@
     "winston-daily-rotate-file": "^4.7.1"
   },
   "devDependencies": {
-    "@types/node": "^18.16.3"
+    "@types/jest": "^29.5.12",
+    "@types/node": "^18.16.3",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "tsc-alias": "^1.8.8",
+    "typescript": "^5.3.3"
   }
 }

package/release.bat

@@ -1,5 +1,4 @@
-call tsc
-call tsc-alias
-node build.js
-npm publish --access public
+call npm run compile
+call node build.js
+call npm publish --access public
 pause

package/{postinstall.js → scripts/postinstall.js}

@@ -1,6 +1,6 @@
-const currentVersion = require('./package.json').version;
+const currentVersion = require('../package.json').version;
 const path = require('path');
-const { UtilFT } = require("./index");
+const { UtilFT } = require("../index");
 const readline = require('readline');
 
 // 将版本号转换为可以比较的数字

package/src/QuickFunction.ts

@@ -1,37 +1,56 @@
-import { ExtractOutcome, Keyable, Outcome, UnionToIntersection } from "./UtilInterfaces";
-
-/**创建一个Outcome */
-export function outcome<K extends Keyable,V> (key:K,value:V):Outcome<K,V>{
-    return {status:key,result:value}
-}
+import { UtilFunc } from "./UtilFunctions";
+import { Outcome } from "./UtilInterfaces";
+import { Completed, Failed, FailedLike, None, NoneOut, StatusSymbol, Success, SuccessLike, Terminated, Timeout } from "./UtilSymbol";
 
+export const {
+    outcome,
+    matchProc,
+    sucesProc,
+    isFailed,
+    isSafeNumber,
+    isSuccess,
+    assertType,
+    assertLiteral,
+    deepClone,
+    sleep,
+    stringifyJToken,
+    getTime,
+    mapEntries,
+    composeMixinable
+} = UtilFunc;
 
-/**处理联合值
- * @param t       - 目标值
- * @param procObj - 所有可能的id组成的处理函数映射
- * @returns 任意处理函数的返回值
- */
-export function match<
-    T extends Keyable | Outcome<Keyable, unknown>,
-    P extends UnionToIntersection<(T extends Keyable
-        ? {[K in T]:(k:K)=>unknown}
-        : T extends Outcome<Keyable,unknown> 
-            ? { [K in T['status']] : (k:K,v:ExtractOutcome<T,K>['result'])=>unknown }
-            : never)>>
-    (t:T, procObj:P):
-    P extends Record<any,(...args:any)=>any>
-        ? {[K in keyof P]: ReturnType<P[K]>}[keyof P]
-        : never {
-    if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol')
-        return (procObj as any)[t](t);
-    else
-        return (procObj as any)[t.status](t.status,t.result);
-}
 if(false){
+    let aaser = assertLiteral({a:1})
+
     let a:"asd"|"dsa" = null as any;
-    const r = match(a,{
+    const r = matchProc(a,{
         "asd":(a)=>"ssa" as const,
         "dsa":(b)=>"ssb" as const,
     })
+    let b:Outcome<"a","123">|NoneOut = null as any;
+    const r1 = matchProc(b,{
+        "a":(a,s)=>"ssa" as const,
+        [None]:(b,s)=>"ssb" as const,
+    })
+    let udt = outcome("ssa","None");
+
+    type test = Outcome<"a"|"b",any> extends Outcome<"a",12>|Outcome<"b",34>
+        ? "suc" : "fal"
+    let assa = isFailed(null as any as Failed)
+    let assb = isFailed(null as any as Failed|Success)
+    let assc = isFailed(null as any as Success)
+    let asssc = isFailed(null)
+    let assa1 = isFailed(null as any as Outcome<Failed,unknown>)
+    let assb1 = isFailed(null as any as Outcome<Failed|Success,unknown>)
+    let assc1 = isFailed(null as any as Outcome<Success,unknown>)
+
+    let proct = sucesProc(null as any as Outcome<Failed|Success,"123">|Outcome<Failed,"1234">|Outcome<Success,"1s23">,
+        (s)=>"ssa" as const,
+        (f)=>"ssad" as const,
+        ()=>123 as const)
+
+    let matt = matchProc(null as any as Outcome<symbol,123>,{
+
+    })
 }
 

package/src/UtilDecorators.ts

@@ -1,4 +1,5 @@
 import { UtilFunc } from "./UtilFunctions";
+import { UnwrapPromise } from "./UtilInterfaces";
 import { SLogger } from "./UtilLogger";
 
 type TDTg<T> = 
@@ -136,7 +137,7 @@ export function DeferAsync<T extends (...args:any)=>Promise<any>>
     };
 }
 /**try-catch包装 */
-export function DCatch<T extends (...args:any)=>any>
+export function Catch<T extends (...args:any)=>any>
     (catchLogic:(error: any, ...args:Parameters<T>)=>ReturnType<T>):TDTg<T> {
     return function(target, propertyKey, descriptor) {
         const originalMethod = descriptor.value!;
@@ -198,6 +199,7 @@ class Example {
     }
     @LogCall()
     @Defer((a,b)=>null)
+    @CatchAsync(async (a,b)=>123)
     static async myMethod1(num: number,ss:string) {
         return 312;
     }

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, Success, 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,7 +135,7 @@ 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;
 
@@ -164,8 +145,8 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
 
     //进行中的请求
 	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,7 +182,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
 
             //路由请求状态
             const postresult = currObj.result;
-            const result = match(postresult.stat,{
+            const result = UtilFunc.matchProc(postresult.stat,{
                 [Success](){
                     SLogger.info(`第 ${postresult.index+1} 次 repeatPromise 成功`);
                     //非当前
@@ -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, Success, 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]
@@ -84,9 +99,13 @@ 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];
 
 /**部分组合的类 
@@ -124,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]
 };
 /**添加前缀 */
@@ -154,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,18 +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/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