@zwa73/utils 1.0.79 → 1.0.81

package/{test/test.js → backup/repeatPromise.test.ts}

@@ -7,7 +7,6 @@ let index = 0;
 // 模拟的异步函数，有一定几率失败
 async function mockAsyncFunction() {
     return new Promise((resolve, reject) => {
-		
 		let delay =timeList[index];
 		let result = resList[index];
 		console.log("延迟: "+delay,"结果: "+result)

package/compile.bat

@@ -0,0 +1,2 @@
+npm run compile
+pause

package/dist/QuickFunction.d.ts

@@ -1,15 +1,2 @@
-import { ExtractOutcome, Keyable, Outcome } from "./UtilInterfaces";
-/**创建一个outcome */
-export declare function outcome<K extends Keyable, V>(key: K, value: V): Outcome<K, V>;
-/**处理联合 简单值
- * @param t       - 目标值
- * @param procObj - 所有可能的id组成的处理函数映射
- * @returns 任意处理函数的返回值
- */
-export declare function match<T extends Keyable | Outcome<Keyable, unknown>, P extends (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;
+import { UtilFunc } from "./UtilFunctions";
+export declare const outcome: typeof UtilFunc.outcome, matchProc: typeof UtilFunc.matchProc, sucesProc: typeof UtilFunc.sucesProc, isFailed: typeof UtilFunc.isFailed, isSafeNumber: typeof UtilFunc.isSafeNumber, isSuccess: typeof UtilFunc.isSuccess, assertType: typeof UtilFunc.assertType, assertLiteral: typeof UtilFunc.assertLiteral, deepClone: typeof UtilFunc.deepClone, sleep: typeof UtilFunc.sleep, stringifyJToken: typeof UtilFunc.stringifyJToken, getTime: typeof UtilFunc.getTime, mapEntries: typeof UtilFunc.mapEntries, composeMixinable: typeof UtilFunc.composeMixinable;

package/dist/QuickFunction.js

@@ -1,27 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.match = exports.outcome = void 0;
-/**创建一个outcome */
-function outcome(key, value) {
-    return { status: key, result: value };
-}
-exports.outcome = outcome;
-/**处理联合 简单值
- * @param t       - 目标值
- * @param procObj - 所有可能的id组成的处理函数映射
- * @returns 任意处理函数的返回值
- */
-function match(t, procObj) {
-    if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol')
-        return procObj[t](t);
-    else
-        return procObj[t.status](t.status, t.result);
-}
-exports.match = match;
+exports.composeMixinable = exports.mapEntries = exports.getTime = exports.stringifyJToken = exports.sleep = exports.deepClone = exports.assertLiteral = exports.assertType = exports.isSuccess = exports.isSafeNumber = exports.isFailed = exports.sucesProc = exports.matchProc = exports.outcome = void 0;
+const UtilFunctions_1 = require("./UtilFunctions");
+const UtilSymbol_1 = require("./UtilSymbol");
+exports.outcome = UtilFunctions_1.UtilFunc.outcome, exports.matchProc = UtilFunctions_1.UtilFunc.matchProc, exports.sucesProc = UtilFunctions_1.UtilFunc.sucesProc, exports.isFailed = UtilFunctions_1.UtilFunc.isFailed, exports.isSafeNumber = UtilFunctions_1.UtilFunc.isSafeNumber, exports.isSuccess = UtilFunctions_1.UtilFunc.isSuccess, exports.assertType = UtilFunctions_1.UtilFunc.assertType, exports.assertLiteral = UtilFunctions_1.UtilFunc.assertLiteral, exports.deepClone = UtilFunctions_1.UtilFunc.deepClone, exports.sleep = UtilFunctions_1.UtilFunc.sleep, exports.stringifyJToken = UtilFunctions_1.UtilFunc.stringifyJToken, exports.getTime = UtilFunctions_1.UtilFunc.getTime, exports.mapEntries = UtilFunctions_1.UtilFunc.mapEntries, exports.composeMixinable = UtilFunctions_1.UtilFunc.composeMixinable;
 if (false) {
+    let aaser = (0, exports.assertLiteral)({ a: 1 });
     let a = null;
-    const r = match(a, {
+    const r = (0, exports.matchProc)(a, {
         "asd": (a) => "ssa",
         "dsa": (b) => "ssb",
     });
+    let b = null;
+    const r1 = (0, exports.matchProc)(b, {
+        "a": (a, s) => "ssa",
+        [UtilSymbol_1.None]: (b, s) => "ssb",
+    });
+    let udt = (0, exports.outcome)("ssa", "None");
+    let assa = (0, exports.isFailed)(null);
+    let assb = (0, exports.isFailed)(null);
+    let assc = (0, exports.isFailed)(null);
+    let asssc = (0, exports.isFailed)(null);
+    let assa1 = (0, exports.isFailed)(null);
+    let assb1 = (0, exports.isFailed)(null);
+    let assc1 = (0, exports.isFailed)(null);
+    let proct = (0, exports.sucesProc)(null, (s) => "ssa", (f) => "ssad", () => 123);
+    let matt = (0, exports.matchProc)(null, {});
 }

package/dist/UtilCodecs.js

@@ -111,4 +111,4 @@ var UtilCodec;
         return textDecoder.decode(encoderDavinci?.decode(arr));
     }
     UtilCodec.decodeTokenDavinci = decodeTokenDavinci;
-})(UtilCodec = exports.UtilCodec || (exports.UtilCodec = {}));
+})(UtilCodec || (exports.UtilCodec = UtilCodec = {}));

package/dist/UtilCom.js

@@ -154,4 +154,4 @@ var UtilCom;
         return sRepeatPost("http", json, options, timeLimit, repeatCount, repeatTime, verifyFn);
     }
     UtilCom.shttpRepeatPost = shttpRepeatPost;
-})(UtilCom = exports.UtilCom || (exports.UtilCom = {}));
+})(UtilCom || (exports.UtilCom = UtilCom = {}));

package/dist/UtilDecorators.d.ts

@@ -23,7 +23,7 @@ export declare function Defer<T extends (...args: any) => any>(deferLogic: (...a
 /**异步的try-finally包装 */
 export declare function DeferAsync<T extends (...args: any) => Promise<any>>(deferLogic: (...args: Parameters<T>) => any | Promise<any>): TDTg<T>;
 /**try-catch包装 */
-export declare function DCatch<T extends (...args: any) => any>(catchLogic: (error: any, ...args: Parameters<T>) => ReturnType<T>): TDTg<T>;
+export declare function Catch<T extends (...args: any) => any>(catchLogic: (error: any, ...args: Parameters<T>) => ReturnType<T>): TDTg<T>;
 /**异步的try-catch包装 */
 export declare function CatchAsync<T extends (...args: any) => Promise<any>>(catchLogic: (error: any, ...args: Parameters<T>) => ReturnType<T>): TDTg<T>;
 export {};

package/dist/UtilDecorators.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CatchAsync = exports.DCatch = exports.DeferAsync = exports.Defer = exports.LogErrAsync = exports.LogErr = exports.LogCallAsync = exports.LogCall = exports.LogTimeAsync = exports.LogTime = void 0;
+exports.CatchAsync = exports.Catch = exports.DeferAsync = exports.Defer = exports.LogErrAsync = exports.LogErr = exports.LogCallAsync = exports.LogCall = exports.LogTimeAsync = exports.LogTime = void 0;
 const UtilFunctions_1 = require("./UtilFunctions");
 const UtilLogger_1 = require("./UtilLogger");
 /**用于打印方法运行时间
@@ -146,7 +146,7 @@ function DeferAsync(deferLogic) {
 }
 exports.DeferAsync = DeferAsync;
 /**try-catch包装 */
-function DCatch(catchLogic) {
+function Catch(catchLogic) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = function (...args) {
@@ -162,7 +162,7 @@ function DCatch(catchLogic) {
         return descriptor;
     };
 }
-exports.DCatch = DCatch;
+exports.Catch = Catch;
 /**异步的try-catch包装 */
 function CatchAsync(catchLogic) {
     return function (target, propertyKey, descriptor) {
@@ -208,6 +208,7 @@ __decorate([
 __decorate([
     LogCall(),
     Defer((a, b) => null),
+    CatchAsync(async (a, b) => 123),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Number, String]),
     __metadata("design:returntype", Promise)

package/dist/UtilFP.js

@@ -51,4 +51,4 @@ var UtilFP;
     console.log(sumb(true));
     console.log(sumc("s",3,false));
      */
-})(UtilFP = exports.UtilFP || (exports.UtilFP = {}));
+})(UtilFP || (exports.UtilFP = UtilFP = {}));

package/dist/UtilFileTools.js

@@ -204,4 +204,4 @@ var UtilFT;
         throw "请使用 fileSearchRegex 或 fileSearchGlob";
     }
     UtilFT.fileSearch = fileSearch;
-})(UtilFT = exports.UtilFT || (exports.UtilFT = {}));
+})(UtilFT || (exports.UtilFT = UtilFT = {}));

package/dist/UtilFunctions.d.ts

@@ -1,7 +1,7 @@
-import { ComposedClass, ComposedMixinable, IJData, JObject, JToken, Mixinable, Outcome, PromiseVerifyFn } from "./UtilInterfaces";
-import { Completed, Timeout } from "./UtilSymbol";
-type CompleteCome<T> = Outcome<Completed, T>;
-type TimeoutCome<T> = Outcome<Timeout, Promise<T>>;
+import { AnyFunc, ComposedClass, ComposedMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, LiteralCheck, Matchable, MatchableFlag, Mixinable, Outcome, PromiseVerifyFn, UnionToIntersection } from "./UtilInterfaces";
+import { FailedLike, None, StatusSymbol, Success, SuccessLike, Timeout } from "./UtilSymbol";
+type SuccessOut<T> = Outcome<Success, T>;
+type TimeoutOut<T> = Outcome<Timeout, Promise<T>>;
 /**常用函数 */
 export declare class UtilFunc {
     /**获取当前时间戳
@@ -33,17 +33,6 @@ export declare class UtilFunc {
      * @returns hash
      */
     static calcHash(str: string): string;
-    /**深克隆 序列化并反序列化
-     * @template T - JToken类型的泛型
-     * @param obj  - 克隆目标
-     * @returns 克隆结果
-     */
-    static deepClone<T extends JToken>(obj: T): T;
-    /**是否为安全的数字
-     * @param num - 所要检测的数字
-     * @returns 是否安全
-     */
-    static isSafeNumber(num: number): boolean;
     /**等待 timeMs 毫秒
      * @async
      * @param timeMs - 等待的毫秒数
@@ -71,7 +60,7 @@ export declare class UtilFunc {
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
      * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为10秒
+     * @param repeatTime  - 超时时间/秒  最小为5秒
      * @returns 结果 null 为全部失败/超时
      */
     static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
@@ -80,7 +69,7 @@ export declare class UtilFunc {
      * @param timeLimit - 毫秒限时
      * @returns 超时则返回 处理函数委托 完成则返回结果
      */
-    static timelimitPromise<T>(func: () => Promise<T> | T, timeLimit?: number): Promise<CompleteCome<T> | TimeoutCome<T>>;
+    static timelimitPromise<T>(func: () => Promise<T> | T, timeLimit?: number): Promise<SuccessOut<T> | TimeoutOut<T>>;
     /**部分类组合
      * 将mixin的部分字段混入base
      * @param base   - 基础类
@@ -98,12 +87,70 @@ export declare class UtilFunc {
      * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
-    static mapEntries<T extends Object>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
+    static mapEntries<T extends object>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
     /**将JToken转换为字符串
      * @param token - 待转换的Token
      * @param space - 插入的空格 数字为空格数量 默认为制表符\t
      * @returns 转换完成的字符串
      */
     static stringifyJToken(token: JToken | IJData, space?: string | number | null | undefined): string;
+    /**代办表 用于队列处理等待 */
+    static pendingMap: Record<Keyable, AnyFunc[]>;
+    /**队列处理
+     * 等待标签为 flag 的队列
+     * 直到排在之前的任务全部完成再处理当前Promise
+     * @param flag - 队列标签
+     * @param task - 任务逻辑
+     * @returns 处理结果
+     */
+    static queueProc<T>(flag: Keyable, task: (() => Promise<T>) | Promise<T>): Promise<T>;
+    /**创建一个Outcome */
+    static outcome<K extends Keyable, V>(key: K, value: V): Outcome<K, V>;
+    /**处理联合值
+     * @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;
+    /**根据典型的成功或失败状态运行函数
+     * @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>;
+    /**是失败的 */
+    static isFailed<T>(tg: T): T extends Matchable<FailedLike> ? true : MatchableFlag<T> extends Exclude<MatchableFlag<T>, FailedLike> ? false : boolean;
+    /**是成功的 */
+    static isSuccess<T>(tg: T): T extends Matchable<SuccessLike> ? true : MatchableFlag<T> extends Exclude<MatchableFlag<T>, SuccessLike> ? false : boolean;
+    /**验证一个变量的类型是否为 T
+     * @template T - 验证类型
+     * @param t    - 验证目标
+     */
+    static assertType<T>(t: T): T;
+    /**验证一个变量的类型是否为字面量
+     * 仅限浅层
+     * @template T - 验证类型
+     * @param t    - 验证目标
+     */
+    static assertLiteral<T>(t: LiteralCheck<T>): T;
+    /**深克隆 序列化并反序列化
+     * @template T - JToken类型的泛型
+     * @param obj  - 克隆目标
+     * @returns 克隆结果
+     */
+    static deepClone<T extends JToken>(obj: T): T;
+    /**是否为安全的数字
+     * 非NaN 非null/undefined
+     * 且是数字
+     * @param num - 所要检测的数字
+     * @returns 是否安全
+     */
+    static isSafeNumber(num: unknown): boolean;
 }
 export {};

package/dist/UtilFunctions.js

@@ -14,7 +14,6 @@ const crypto = require("crypto");
 const cp = require("child_process");
 const UtilLogger_1 = require("./UtilLogger");
 const UtilSymbol_1 = require("./UtilSymbol");
-const QuickFunction_1 = require("./QuickFunction");
 const UtilDecorators_1 = require("./UtilDecorators");
 /**永不完成的Promise单例 */
 const NeverResolvedPromise = new Promise(() => { });
@@ -72,25 +71,6 @@ class UtilFunc {
     static calcHash(str) {
         return crypto.createHash('md5').update(str).digest('hex');
     }
-    /**深克隆 序列化并反序列化
-     * @template T - JToken类型的泛型
-     * @param obj  - 克隆目标
-     * @returns 克隆结果
-     */
-    static deepClone(obj) {
-        return JSON.parse(JSON.stringify(obj));
-    }
-    /**是否为安全的数字
-     * @param num - 所要检测的数字
-     * @returns 是否安全
-     */
-    static isSafeNumber(num) {
-        if (num === undefined || num == null || isNaN(num))
-            return false;
-        if (typeof num === 'number')
-            return true;
-        return false;
-    }
     static async sleep(timeMs, result) {
         return new Promise(function (resolve, rejecte) {
             let timer = setTimeout(function () {
@@ -120,18 +100,18 @@ class UtilFunc {
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
      * @param repeatCount - 重试次数
-     * @param repeatTime  - 超时时间/秒  最小为10秒
+     * @param repeatTime  - 超时时间/秒  最小为5秒
      * @returns 结果 null 为全部失败/超时
      */
     static async repeatPromise(procFn, verifyFn, repeatCount = 3, repeatTime = 180) {
         /**是否含有超时时间 */
-        const hasRepeatTime = (repeatTime >= 10);
+        const hasRepeatTime = (repeatTime >= 5);
         //转换为毫秒
         if (hasRepeatTime)
             repeatTime *= 1000;
         //验证处理函数
         if (verifyFn === undefined)
-            verifyFn = () => UtilSymbol_1.Completed;
+            verifyFn = () => UtilSymbol_1.Success;
         //进行中的请求
         const plist = [];
         //开始处理
@@ -155,7 +135,7 @@ class UtilFunc {
                     //解除timeout替换原参数
                     plist[i] = new Promise(async (rslove) => {
                         const res = await currObj.result;
-                        rslove((0, QuickFunction_1.outcome)(UtilSymbol_1.Completed, res));
+                        rslove(UtilFunc.outcome(UtilSymbol_1.Success, res));
                     });
                     UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
                     i++;
@@ -163,8 +143,8 @@ class UtilFunc {
                 }
                 //路由请求状态
                 const postresult = currObj.result;
-                const result = (0, QuickFunction_1.match)(postresult.stat, {
-                    [UtilSymbol_1.Completed]() {
+                const result = UtilFunc.matchProc(postresult.stat, {
+                    [UtilSymbol_1.Success]() {
                         UtilLogger_1.SLogger.info(`第 ${postresult.index + 1} 次 repeatPromise 成功`);
                         //非当前
                         if (postresult.index != i)
@@ -212,18 +192,18 @@ class UtilFunc {
             const procer = (async () => await func())();
             const procerP = new Promise(async (resolve) => {
                 const res = await procer;
-                resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Completed, res));
+                resolve(UtilFunc.outcome(UtilSymbol_1.Success, res));
                 if (clearTimer)
                     clearTimer();
             });
             const timerP = timeLimit
                 ? new Promise((resolve) => {
-                    const timer = setTimeout(() => resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Timeout, procer)), timeLimit); //无限制则无限时间
+                    const timer = setTimeout(() => resolve(UtilFunc.outcome(UtilSymbol_1.Timeout, procer)), timeLimit); //无限制则无限时间
                     clearTimer = () => {
-                        resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Timeout, procer));
+                        resolve(UtilFunc.outcome(UtilSymbol_1.Timeout, procer));
                         clearInterval(timer);
                     };
-                })
+                }) //未定义时间限制则无限
                 : UtilFunc.getNeverResolvedPromise();
             const result = Promise.race([procerP, timerP]);
             reslove(result);
@@ -308,11 +288,143 @@ class UtilFunc {
             space = undefined;
         return JSON.stringify(token, null, space);
     }
+    /**代办表 用于队列处理等待 */
+    static pendingMap = {};
+    /**队列处理
+     * 等待标签为 flag 的队列
+     * 直到排在之前的任务全部完成再处理当前Promise
+     * @param flag - 队列标签
+     * @param task - 任务逻辑
+     * @returns 处理结果
+     */
+    static async queueProc(flag, task) {
+        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) {
+            UtilLogger_1.SLogger.fatal(`queuePromise 出现错误`, e);
+            throw e;
+        }
+        finally {
+            tryRes();
+        }
+    }
+    /**创建一个Outcome */
+    static outcome(key, value) {
+        return {
+            status: key,
+            result: value
+        };
+    }
+    /**处理联合值
+     * @param t       - 目标值
+     * @param procObj - 所有可能的id组成的处理函数映射 (status, result)=>any
+     * @returns 任意处理函数的返回值
+     */
+    static matchProc(t, procObj) {
+        if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol') {
+            if (procObj[t])
+                return procObj[t](t);
+            UtilLogger_1.SLogger.fatal(`matchProc 传入了一个预料之外的值: `, t);
+            throw UtilSymbol_1.None;
+        }
+        else {
+            if (procObj[t.status])
+                return procObj[t.status](t.status, t.result);
+            UtilLogger_1.SLogger.fatal(`matchProc 传入了一个预料之外的值: `, t);
+            throw UtilSymbol_1.None;
+        }
+    }
+    /**根据典型的成功或失败状态运行函数
+     * @param t - 目标值
+     * @param sucessFunc - 成功则运行的函数 (result)=>any
+     * @param failedFunc - 失败则运行的函数 (result)=>any
+     * @param noneFunc   - 无结果或不匹配时运行的函数 ()=>any
+     * @returns 非成功或失败时返回 None
+     */
+    static sucesProc(t, sucessFunc, failedFunc, noneFunc) {
+        failedFunc = failedFunc ?? (() => UtilSymbol_1.None);
+        noneFunc = noneFunc ?? (() => UtilSymbol_1.None);
+        const val = typeof t === 'symbol' ? undefined : t.result;
+        if (UtilFunc.isSuccess(t))
+            return sucessFunc(val);
+        if (UtilFunc.isFailed(t))
+            return failedFunc(val);
+        if (t !== UtilSymbol_1.None)
+            UtilLogger_1.SLogger.warn(`sucesProc 传入了一个不匹配的值, 将作为None运行: `, t);
+        return noneFunc();
+    }
+    /**是失败的 */
+    static isFailed(tg) {
+        const test = (t) => t === UtilSymbol_1.Failed || t === UtilSymbol_1.Terminated || t === UtilSymbol_1.Timeout;
+        if (tg != null && typeof tg === 'object' && 'status' in tg)
+            return test(tg.status);
+        return test(tg);
+    }
+    /**是成功的 */
+    static isSuccess(tg) {
+        const test = (t) => t === UtilSymbol_1.Success || t === UtilSymbol_1.Completed;
+        if (tg != null && typeof tg === 'object' && 'status' in tg)
+            return test(tg.status);
+        return test(tg);
+    }
+    /**验证一个变量的类型是否为 T
+     * @template T - 验证类型
+     * @param t    - 验证目标
+     */
+    static assertType(t) { return t; }
+    /**验证一个变量的类型是否为字面量
+     * 仅限浅层
+     * @template T - 验证类型
+     * @param t    - 验证目标
+     */
+    static assertLiteral(t) { return t; }
+    /**深克隆 序列化并反序列化
+     * @template T - JToken类型的泛型
+     * @param obj  - 克隆目标
+     * @returns 克隆结果
+     */
+    static deepClone(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+    /**是否为安全的数字
+     * 非NaN 非null/undefined
+     * 且是数字
+     * @param num - 所要检测的数字
+     * @returns 是否安全
+     */
+    static isSafeNumber(num) {
+        if (num == null)
+            return false;
+        if (typeof num === 'number') {
+            if (isNaN(num))
+                return false;
+            return true;
+        }
+        return false;
+    }
 }
+exports.UtilFunc = UtilFunc;
 __decorate([
     (0, UtilDecorators_1.LogTimeAsync)("repeatPromise ", true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Function, Function, Number, Number]),
     __metadata("design:returntype", Promise)
 ], UtilFunc, "repeatPromise", null);
-exports.UtilFunc = UtilFunc;

package/dist/UtilInterfaces.d.ts

@@ -1,4 +1,4 @@
-import { Completed, Failed, Terminated } from "./UtilSymbol";
+import { Failed, Success, Terminated } from "./UtilSymbol";
 /**可以序列化为JSON文件的对象 */
 export type JToken = JObject | JArray | JValue | IJData;
 /**在stringify输出时 undefine 会被转为 null */
@@ -15,8 +15,14 @@ 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];
@@ -32,6 +38,11 @@ export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> = R[
  * (string&String)
  */
 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 的新属性。
  * 所有 K 中非 K[N] 的其他属性都是可选的并且不能被赋值（因为它们的类型是 never）。
@@ -56,12 +67,14 @@ export type ExclusiveJObject<B extends JObject, T extends JToken, K extends stri
  * 终止 将直接返回  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];
 /**部分组合的类
  * @template Base     - 基类
@@ -91,16 +104,9 @@ export type ComposedMixinable<B, Ms extends unknown[]> = Ms extends [infer M, ..
  * @template N - 如果为假的返回值
  */
 export type ExtendThen<B, T, Y, N = never> = B extends T ? Y : N;
-/** 一个联合类型 B 中如果包含 T
- * @template B - 基础类型
- * @template T - 判断的目标类型
- * @template Y - 如果为真的返回值
- * @template N - 如果为假的返回值
- */
-export type UnionInclude<B, T, Y, N = never> = B extends Exclude<B, T> ? Y : N;
 /**排除可选字段 */
 export type RequiredOnly<T> = {
-    [K in keyof T as UnionInclude<T[K], undefined, never, K>]: T[K];
+    [K in keyof T as T[K] extends Exclude<T[K], undefined> ? K : never]: T[K];
 };
 /**添加前缀 */
 export type WithPrefix<T, P extends string> = {
@@ -112,10 +118,14 @@ 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 */
-export type ExtractOutcome<T, K extends Keyable> = T extends Outcome<K, unknown> ? T : never;
+/**可进行匹配的 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<infer O, unknown> ? O extends Exclude<O, K> ? never : T : never;
 export {};

package/dist/UtilSymbol.d.ts

@@ -1,15 +1,37 @@
-/**完成 */
-export declare const Completed: unique symbol;
-export type Completed = typeof Completed;
-/**失败 */
+import { Outcome } from "./UtilInterfaces";
+/**成功 经过验证的结果 */
+export declare const Success: unique symbol;
+export type Success = typeof Success;
+/**失败 可重试的 */
 export declare const Failed: unique symbol;
 export type Failed = typeof Failed;
-/**终止 */
-export declare const Terminated: unique symbol;
-export type Terminated = typeof Terminated;
-/**不存在 */
+/**不存在 无 */
 export declare const None: unique symbol;
 export type None = typeof None;
-/**超时 */
+/**完成 未经验证/未超时的结果
+ * Success扩展
+ * 仅在Success同时出现时使用
+ */
+export declare const Completed: unique symbol;
+export type Completed = typeof Completed;
+/**终止 熔断运行
+ * Failed扩展
+ * 仅在Failed同时出现时使用
+ */
+export declare const Terminated: unique symbol;
+export type Terminated = typeof Terminated;
+/**超时 超时类型的失败
+ * Failed扩展
+ * 仅在超时时使用
+ */
 export declare const Timeout: unique symbol;
 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 declare const NoneOut: NoneOut;