@zwa73/utils 1.0.80 → 1.0.81

package/dist/test/test.js

@@ -33,25 +33,25 @@ om.monfunc1(); //?
 om.m1num; //?
 const BASE_MAX = { 攻击: 24, 生命: 54, 防御: 16, 暴击: 5, 暴击伤害: 5, 攻击加成: 3.8, 生命加成: 3.8, 防御加成: 3.8 };
 const 精调前 = [
-    { 攻击: 17, 生命: 0, 防御: 0, 暴击: 0, 暴击伤害: 3.5, 攻击加成: 3.0, 生命加成: 0, 防御加成: 3.4 },
-    { 攻击: 19, 生命: 0, 防御: 0, 暴击: 4.5, 暴击伤害: 4.5, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 21, 生命: 0, 防御: 10, 暴击: 0, 暴击伤害: 0, 攻击加成: 3.8, 生命加成: 0, 防御加成: 3.0 },
-    { 攻击: 17, 生命: 48, 防御: 14, 暴击: 0, 暴击伤害: 0, 攻击加成: 2.6, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 23, 生命: 0, 防御: 0, 暴击: 5, 暴击伤害: 0, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 17, 生命: 53, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 21, 生命: 0, 防御: 0, 暴击: 3.5, 暴击伤害: 0, 攻击加成: 3.0, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 17, 生命: 0, 防御: 3.8, 暴击: 0, 暴击伤害: 0, 攻击加成: 2.6, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 17, 生命: 0, 防御: 0, 暴击: 0, 暴击伤害: 3.5, 攻击加成: 3.0, 生命加成: 0, 防御加成: 3.4 }, // 霰弹 专用消焰器
+    { 攻击: 19, 生命: 0, 防御: 0, 暴击: 4.5, 暴击伤害: 4.5, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 }, // 霰弹 专用消音器
+    { 攻击: 21, 生命: 0, 防御: 10, 暴击: 0, 暴击伤害: 0, 攻击加成: 3.8, 生命加成: 0, 防御加成: 3.0 }, // 机枪 重型制退器
+    { 攻击: 17, 生命: 48, 防御: 14, 暴击: 0, 暴击伤害: 0, 攻击加成: 2.6, 生命加成: 0, 防御加成: 0 }, // 冲锋 消焰器攻击头
+    { 攻击: 23, 生命: 0, 防御: 0, 暴击: 5, 暴击伤害: 0, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 }, // 狙击 异位打击 快拆战术手电
+    { 攻击: 17, 生命: 53, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 }, // 霰弹 减伤支援 钢化铆钉
+    { 攻击: 21, 生命: 0, 防御: 0, 暴击: 3.5, 暴击伤害: 0, 攻击加成: 3.0, 生命加成: 0, 防御加成: 0 }, // 冲锋 异位打击 内瞄式红点
+    { 攻击: 17, 生命: 0, 防御: 3.8, 暴击: 0, 暴击伤害: 0, 攻击加成: 2.6, 生命加成: 0, 防御加成: 0 }, // 机枪 双重对策 镭射插件
     { 攻击: 19, 生命: 38, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 }, // 机枪 双重对策 折叠脚架
 ];
 const 精调后 = [
-    { 攻击: 26, 生命: 0, 防御: 0, 暴击: 0, 暴击伤害: 8.1, 攻击加成: 7.5, 生命加成: 0, 防御加成: 5.8 },
-    { 攻击: 31, 生命: 0, 防御: 0, 暴击: 10.4, 暴击伤害: 10.4, 攻击加成: 7.5, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 49, 生命: 0, 防御: 17, 暴击: 0, 暴击伤害: 0, 攻击加成: 7.6, 生命加成: 0, 防御加成: 6.9 },
-    { 攻击: 46, 生命: 116, 防御: 27, 暴击: 0, 暴击伤害: 0, 攻击加成: 5.0, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 42, 生命: 0, 防御: 0, 暴击: 11.5, 暴击伤害: 0, 攻击加成: 6.8, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 34, 生命: 101, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 6.5, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 38, 生命: 0, 防御: 0, 暴击: 8.4, 暴击伤害: 0, 攻击加成: 4.8, 生命加成: 0, 防御加成: 0 },
-    { 攻击: 43, 生命: 0, 防御: 8.0, 暴击: 0, 暴击伤害: 0, 攻击加成: 7.3, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 26, 生命: 0, 防御: 0, 暴击: 0, 暴击伤害: 8.1, 攻击加成: 7.5, 生命加成: 0, 防御加成: 5.8 }, // 霰弹 专用消焰器
+    { 攻击: 31, 生命: 0, 防御: 0, 暴击: 10.4, 暴击伤害: 10.4, 攻击加成: 7.5, 生命加成: 0, 防御加成: 0 }, // 霰弹 专用消音器
+    { 攻击: 49, 生命: 0, 防御: 17, 暴击: 0, 暴击伤害: 0, 攻击加成: 7.6, 生命加成: 0, 防御加成: 6.9 }, // 机枪 重型制退器
+    { 攻击: 46, 生命: 116, 防御: 27, 暴击: 0, 暴击伤害: 0, 攻击加成: 5.0, 生命加成: 0, 防御加成: 0 }, // 冲锋 消焰器攻击头
+    { 攻击: 42, 生命: 0, 防御: 0, 暴击: 11.5, 暴击伤害: 0, 攻击加成: 6.8, 生命加成: 0, 防御加成: 0 }, // 狙击 异位打击 快拆战术
+    { 攻击: 34, 生命: 101, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 6.5, 生命加成: 0, 防御加成: 0 }, // 霰弹 减伤支援 钢化铆钉
+    { 攻击: 38, 生命: 0, 防御: 0, 暴击: 8.4, 暴击伤害: 0, 攻击加成: 4.8, 生命加成: 0, 防御加成: 0 }, // 冲锋 异位打击 内瞄式红
+    { 攻击: 43, 生命: 0, 防御: 8.0, 暴击: 0, 暴击伤害: 0, 攻击加成: 7.3, 生命加成: 0, 防御加成: 0 }, // 机枪 双重对策 镭射插件
     { 攻击: 42, 生命: 54, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 6.2, 生命加成: 0, 防御加成: 0 }, // 机枪 双重对策 折叠脚架
 ];
 const Pointify = (ed) => UtilFunctions_1.UtilFunc.mapEntries(ed, (k, v) => v ? v / BASE_MAX[k] : 0);

package/jest/UtilFunction/queueProc.test.ts

@@ -0,0 +1,23 @@
+import { UtilFunc } from '@';
+import { test, expect } from '@jest/globals';
+
+test('queueProc function', async () => {
+    const results:number[] = [];
+    const expectedResults:number[] = [];
+    const tasks = Array.from({length: 10}, (_, i) => {
+        const result = Math.floor(Math.random() * 100); // 随机生成结果
+        expectedResults.push(result);
+        return async () => {
+            await UtilFunc.sleep(Math.random() * 800); // 随机延迟
+            results.push(result); 
+        };
+    });
+    console.log("结果应该为:",expectedResults);
+
+    // 同时启动所有任务，但由于 queueProc 的设计，它们应该按顺序完成
+    const promises = tasks.map(task => UtilFunc.queueProc('test', task));
+    await Promise.all(promises);
+
+    // 检查结果是否按顺序
+    expect(results).toEqual(expectedResults);
+},10000);

package/jest/UtilFunction/repeatPromise.test.ts

@@ -0,0 +1,38 @@
+import { Completed, Failed, PromiseStat, PromiseVerifyFn, Success, UtilFunc } from "@";
+import { test, expect } from '@jest/globals';
+
+
+
+
+const timeList = [8000,1000,1000000] as const;
+const resList  = [Success,Failed,Failed] as const;
+let index = 0;
+
+// 模拟的异步函数，有一定几率失败
+async function mockAsyncFunction() {
+    return new Promise<Success|Failed>((resolve, reject) => {
+		let delay = timeList[index];
+		let result = resList[index];
+        console.log('当前预期 延迟:',delay,' 结果:',result);
+        setTimeout(() => {
+            resolve(result);
+        }, delay);
+		index++;
+    });
+}
+
+// 验证函数，只有当结果为 "Success" 时才认为成功
+function mockVerifyFunction(result:Success|Failed):PromiseStat {
+    return result === Success ? Success : Failed;
+}
+
+// 测试 repeatPromise 函数
+test('repeatPromise', async () => {
+    const repeatCount = 3;
+    const awaitTime = 5;
+    console.log("重试次数:",repeatCount," 超时时间:",awaitTime)
+    const result = await UtilFunc.repeatPromise(
+        mockAsyncFunction, mockVerifyFunction,
+        repeatCount, awaitTime);
+    expect(result).toBe(Success);
+},10000);

package/jest/jest.test.ts

@@ -0,0 +1,46 @@
+import { test, expect } from '@jest/globals';
+// main.test.ts
+const add = (a: number, b: number): number => a + b;
+
+test('1+2等于3', () => {
+    expect(add(1, 2)).toBe(3);
+});
+test('console.log test', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+
+    // 这里是你的函数，它会打印 "成功" 或 "失败"
+    function yourFunction() {
+        console.log('成功');
+    }
+
+    yourFunction();
+
+    expect(consoleSpy).toHaveBeenCalledWith('成功');
+
+    // 清理 spy
+    consoleSpy.mockRestore();
+});
+
+test('mult console.log test', () => {
+    const consoleSpy = jest.spyOn(console, 'log');
+
+    // 这里是你的函数
+    function yourFunction() {
+        console.log("xxxx1234");
+        console.log("111abc22");
+        console.log("11def");
+        console.log("xxxxxxx");
+    }
+
+    yourFunction();
+
+    // 检查 console.log 的输出中是否包含 "abc" 和 "def"
+    const hasAbc = consoleSpy.mock.calls.some(args => args.some(arg => arg.includes('abc')));
+    const hasDef = consoleSpy.mock.calls.some(args => args.some(arg => arg.includes('def')));
+
+    expect(hasAbc).toBe(true);
+    expect(hasDef).toBe(true);
+
+    // 清理 spy
+    consoleSpy.mockRestore();
+});

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.81",
   "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;
+}
+
 }