@zwa73/utils 1.0.77 → 1.0.78

package/dist/QuickFunction.d.ts

@@ -0,0 +1,15 @@
+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;

package/dist/QuickFunction.js

@@ -0,0 +1,27 @@
+"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;
+if (false) {
+    let a = null;
+    const r = match(a, {
+        "asd": (a) => "ssa",
+        "dsa": (b) => "ssb",
+    });
+}

package/dist/UtilDecorators.d.ts

@@ -1,5 +1,15 @@
 type TDTg<T> = (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
 type DTg = (target: Object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**用于打印方法运行时间
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+export declare function LogTime(flag: string, suffixUID?: boolean): DTg;
+/**用于打印异步方法运行时间
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+export declare function LogTimeAsync(flag: string, suffixUID?: boolean): DTg;
 /**用于打印方法的调用 */
 export declare function LogCall(): DTg;
 /**用于打印异步方法的调用 */

package/dist/UtilDecorators.js

@@ -9,8 +9,45 @@ 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 = void 0;
+exports.CatchAsync = exports.DCatch = 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");
+/**用于打印方法运行时间
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+function LogTime(flag, suffixUID) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const uid = suffixUID ? UtilFunctions_1.UtilFunc.genUUID() : "";
+            UtilLogger_1.SLogger.time(flag + uid);
+            let result = originalMethod.apply(this, args);
+            UtilLogger_1.SLogger.timeEnd(flag + uid);
+            return result;
+        };
+        return descriptor;
+    };
+}
+exports.LogTime = LogTime;
+/**用于打印异步方法运行时间
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+function LogTimeAsync(flag, suffixUID) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            const uid = suffixUID ? UtilFunctions_1.UtilFunc.genUUID() : "";
+            UtilLogger_1.SLogger.time(flag + uid);
+            let result = await originalMethod.apply(this, args);
+            UtilLogger_1.SLogger.timeEnd(flag + uid);
+            return result;
+        };
+        return descriptor;
+    };
+}
+exports.LogTimeAsync = LogTimeAsync;
 /**用于打印方法的调用 */
 function LogCall() {
     return function (target, propertyKey, descriptor) {
@@ -158,7 +195,7 @@ class Example {
     myMethod(num) {
         return num;
     }
-    async myMethod1(num, ss) {
+    static async myMethod1(num, ss) {
         return 312;
     }
 }
@@ -174,7 +211,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Number, String]),
     __metadata("design:returntype", Promise)
-], Example.prototype, "myMethod1", null);
+], Example, "myMethod1", null);
 //let e = new Example();
 //e.myMethod1(1,"");
 //console.log(123);

package/dist/UtilFunctions.d.ts

@@ -1,10 +1,13 @@
-import { ComposedClass, ComposedMixinable, ExtractOutcome, IJData, JObject, JToken, Mixinable, Outcome, PromiseVerifyFn } from "./UtilInterfaces";
+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>>;
 /**常用函数 */
-export declare namespace UtilFunc {
+export declare class UtilFunc {
     /**获取当前时间戳
      * @returns 时间戳
      */
-    function getTime(): number;
+    static getTime(): number;
     /**初始化对象的字段
      * 会改变obj
      * @param obj        - 所要初始化的对象
@@ -12,50 +15,57 @@ export declare namespace UtilFunc {
      * @param defaultVal - 默认值
      * @returns 最终值
      */
-    function initField<T extends object, K extends keyof T>(obj: T, field: K, defaultVal: T[K]): T[K];
+    static initField<T extends object, K extends keyof T>(obj: T, field: K, defaultVal: T[K]): T[K];
     /**初始化一个数据对象
      * @param obj       - 目标对象
      * @param checkObj  - 用于检测的对象 在对应key缺失时赋予对应值 如果值为函数, 则赋予执行结果 如果结果为 undefined 则不赋值
      * @returns 完成初始化的对象
      */
-    function initObject<T extends JObject>(obj: T, checkObj: {
+    static initObject<T extends JObject>(obj: T, checkObj: {
         [P in keyof T]: T[P] | (() => void | T[P]);
     }): any;
     /**生成一串uuid
      * @returns uuid
      */
-    function genUUID(): string;
+    static genUUID(): string;
     /**计算Hash
      * @param str - 待计算的字符串
      * @returns hash
      */
-    function calcHash(str: string): string;
+    static calcHash(str: string): string;
     /**深克隆 序列化并反序列化
      * @template T - JToken类型的泛型
      * @param obj  - 克隆目标
      * @returns 克隆结果
      */
-    function deepClone<T extends JToken>(obj: T): T;
+    static deepClone<T extends JToken>(obj: T): T;
     /**是否为安全的数字
      * @param num - 所要检测的数字
      * @returns 是否安全
      */
-    function isSafeNumber(num: number): boolean;
+    static isSafeNumber(num: number): boolean;
     /**等待 timeMs 毫秒
      * @async
      * @param timeMs - 等待的毫秒数
      * @returns
      */
-    function sleep(timeMs: number): Promise<boolean>;
+    static sleep<T>(timeMs: number): Promise<void>;
+    /**等待 timeMs 毫秒
+     * @async
+     * @param timeMs - 等待的毫秒数
+     * @param result - 结果
+     * @returns
+     */
+    static sleep<T>(timeMs: number, result: T): Promise<T>;
     /**封装的 cp.exec 执行一段指令 指令完成后返回 Promise
      * @param command 指令文本
      */
-    function exec(command: string): Promise<{
+    static exec(command: string): Promise<{
         stdout: string;
         stderr: string;
     }>;
     /**获得一个永不完成的Promise单例 */
-    function getNeverResolvedPromise<T>(): Promise<T>;
+    static getNeverResolvedPromise<T>(): Promise<T>;
     /**重复尝试promise
      * @async
      * @param procFn      - 发起函数
@@ -64,7 +74,13 @@ export declare namespace UtilFunc {
      * @param repeatTime  - 超时时间/秒  最小为10秒
      * @returns 结果 null 为全部失败/超时
      */
-    function repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
+    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
+    /**创建一个限时的Promise
+     * @param func      - 处理函数
+     * @param timeLimit - 毫秒限时
+     * @returns 超时则返回 处理函数委托 完成则返回结果
+     */
+    static timelimitPromise<T>(func: () => Promise<T> | T, timeLimit?: number): Promise<CompleteCome<T> | TimeoutCome<T>>;
     /**部分类组合
      * 将mixin的部分字段混入base
      * @param base   - 基础类
@@ -73,40 +89,21 @@ export declare namespace UtilFunc {
      * @param fields - 需要混入的字段
      * @returns 混合完成的类
      */
-    function composeClassPart<Base extends object, Mixin extends object, Field extends keyof Mixin>(base: Base, mixin: Mixin, key: string, ...fields: Field[]): ComposedClass<Base, Mixin, typeof key, Field>;
+    static composeClassPart<Base extends object, Mixin extends object, Field extends keyof Mixin>(base: Base, mixin: Mixin, key: string, ...fields: Field[]): ComposedClass<Base, Mixin, typeof key, Field>;
     /**根据 MIXIN_FIELDS 自动混入 */
-    function composeMixinable<Base extends object, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
+    static composeMixinable<Base extends object, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象
      * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
-    function mapEntries<T extends Object>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
-    /**处理联合 Outcome
-     * @param t       - 目标值
-     * @param procObj - 所有可能的id组成的处理函数映射
-     * @returns 任意处理函数的返回值
-     */
-    function matchOutcome<T extends Outcome<string, unknown>, P extends {
-        [K in T['status']]: (k: K, v: ExtractOutcome<T, K>['result']) => unknown;
-    }>(t: T, procObj: P): {
-        [K in keyof P]: ReturnType<P[K]>;
-    }[keyof P];
-    /**处理联合 字符串
-     * @param t       - 目标值
-     * @param procObj - 所有可能的id组成的处理函数映射
-     * @returns 任意处理函数的返回值
-     */
-    function matchStr<T extends string, P extends {
-        [K in T]: (k: K) => unknown;
-    }>(t: T, procObj: P): {
-        [K in keyof P]: ReturnType<P[K]>;
-    }[keyof P];
+    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 转换完成的字符串
      */
-    function stringifyJToken(token: JToken | IJData, space?: string | number | null | undefined): string;
+    static stringifyJToken(token: JToken | IJData, space?: string | number | null | undefined): string;
 }
+export {};

package/dist/UtilFunctions.js

@@ -1,19 +1,31 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.UtilFunc = void 0;
 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(() => { });
 /**常用函数 */
-var UtilFunc;
-(function (UtilFunc) {
+class UtilFunc {
     /**获取当前时间戳
      * @returns 时间戳
      */
-    function getTime() {
+    static getTime() {
         return new Date().getTime();
     }
-    UtilFunc.getTime = getTime;
     /**初始化对象的字段
      * 会改变obj
      * @param obj        - 所要初始化的对象
@@ -21,18 +33,17 @@ var UtilFunc;
      * @param defaultVal - 默认值
      * @returns 最终值
      */
-    function initField(obj, field, defaultVal) {
+    static initField(obj, field, defaultVal) {
         if (!(field in obj))
             obj[field] = defaultVal;
         return obj[field];
     }
-    UtilFunc.initField = initField;
     /**初始化一个数据对象
      * @param obj       - 目标对象
      * @param checkObj  - 用于检测的对象 在对应key缺失时赋予对应值 如果值为函数, 则赋予执行结果 如果结果为 undefined 则不赋值
      * @returns 完成初始化的对象
      */
-    function initObject(obj, checkObj) {
+    static initObject(obj, checkObj) {
         const fixobj = obj;
         for (const key in checkObj) {
             if (obj[key] !== undefined)
@@ -48,60 +59,49 @@ var UtilFunc;
         }
         return fixobj;
     }
-    UtilFunc.initObject = initObject;
     /**生成一串uuid
      * @returns uuid
      */
-    function genUUID() {
+    static genUUID() {
         return crypto.randomBytes(16).toString("hex");
     }
-    UtilFunc.genUUID = genUUID;
     /**计算Hash
      * @param str - 待计算的字符串
      * @returns hash
      */
-    function calcHash(str) {
+    static calcHash(str) {
         return crypto.createHash('md5').update(str).digest('hex');
     }
-    UtilFunc.calcHash = calcHash;
     /**深克隆 序列化并反序列化
      * @template T - JToken类型的泛型
      * @param obj  - 克隆目标
      * @returns 克隆结果
      */
-    function deepClone(obj) {
+    static deepClone(obj) {
         return JSON.parse(JSON.stringify(obj));
     }
-    UtilFunc.deepClone = deepClone;
     /**是否为安全的数字
      * @param num - 所要检测的数字
      * @returns 是否安全
      */
-    function isSafeNumber(num) {
+    static isSafeNumber(num) {
         if (num === undefined || num == null || isNaN(num))
             return false;
         if (typeof num === 'number')
             return true;
         return false;
     }
-    UtilFunc.isSafeNumber = isSafeNumber;
-    /**等待 timeMs 毫秒
-     * @async
-     * @param timeMs - 等待的毫秒数
-     * @returns
-     */
-    async function sleep(timeMs) {
+    static async sleep(timeMs, result) {
         return new Promise(function (resolve, rejecte) {
             let timer = setTimeout(function () {
-                resolve(true);
+                resolve(result);
             }, timeMs);
         });
     }
-    UtilFunc.sleep = sleep;
     /**封装的 cp.exec 执行一段指令 指令完成后返回 Promise
      * @param command 指令文本
      */
-    function exec(command) {
+    static exec(command) {
         return new Promise((resolve, reject) => {
             cp.exec(command, (error, stdout, stderr) => {
                 if (error)
@@ -111,14 +111,10 @@ var UtilFunc;
             });
         });
     }
-    UtilFunc.exec = exec;
-    /**永不完成的Promise单例 */
-    const NeverResolvedPromise = new Promise(() => { });
     /**获得一个永不完成的Promise单例 */
-    function getNeverResolvedPromise() {
+    static getNeverResolvedPromise() {
         return NeverResolvedPromise;
     }
-    UtilFunc.getNeverResolvedPromise = getNeverResolvedPromise;
     /**重复尝试promise
      * @async
      * @param procFn      - 发起函数
@@ -127,10 +123,7 @@ var UtilFunc;
      * @param repeatTime  - 超时时间/秒  最小为10秒
      * @returns 结果 null 为全部失败/超时
      */
-    async function repeatPromise(procFn, verifyFn, repeatCount = 3, repeatTime = 180) {
-        //计时
-        const timeflag = "repeatPromise " + UtilFunc.genUUID();
-        UtilLogger_1.SLogger.time(timeflag);
+    static async repeatPromise(procFn, verifyFn, repeatCount = 3, repeatTime = 180) {
         /**是否含有超时时间 */
         const hasRepeatTime = (repeatTime >= 10);
         //转换为毫秒
@@ -138,21 +131,7 @@ var UtilFunc;
             repeatTime *= 1000;
         //验证处理函数
         if (verifyFn === undefined)
-            verifyFn = () => "Completed";
-        /**计时器 */
-        let timer = null;
-        /**计时器 Promise */
-        let timerP = null;
-        /**计时器 Promise 的返回函数 */
-        let resolveFn = null;
-        /**清理计时器 */
-        const clearTimer = () => {
-            if (timer)
-                clearInterval(timer);
-            if (resolveFn)
-                resolveFn("Timeout");
-            timerP = timer = resolveFn = null;
-        };
+            verifyFn = () => UtilSymbol_1.Completed;
         //进行中的请求
         const plist = [];
         //开始处理
@@ -162,53 +141,54 @@ var UtilFunc;
                 UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 repeatPromise`);
                 //如果 plist 中当前下标的任务还未创建 则 创建当前任务
                 if (plist.length < i + 1) {
-                    plist.push(procFn().then(result => ({ result, stat: verifyFn(result), index: i })));
-                }
-                //创建定时器
-                if (timerP == null) {
-                    timerP = new Promise((resolve, rejecte) => {
-                        resolveFn = resolve;
-                        timer = setTimeout(() => resolve("Timeout"), hasRepeatTime ? repeatTime : Infinity); //无限制则无限时间
-                    });
+                    plist.push(UtilFunc.timelimitPromise(async () => {
+                        const result = await procFn();
+                        const stat = await verifyFn(result);
+                        return { result, stat, index: i };
+                    }));
                 }
                 //等待任意任务 或当前计时器完成
-                const currObj = await Promise.race([...plist, timerP]);
+                const currObj = await Promise.race([...plist]);
                 //超时处理
-                if (currObj === "Timeout") {
+                if (currObj.status === UtilSymbol_1.Timeout) {
+                    //解除timeout替换原参数
+                    plist[i] = new Promise(async (rslove) => {
+                        const res = await currObj.result;
+                        rslove((0, QuickFunction_1.outcome)(UtilSymbol_1.Completed, res));
+                    });
                     UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
-                    clearTimer();
                     i++;
                     continue;
                 }
                 //路由请求状态
-                const poststat = await currObj.stat;
-                const result = matchStr(poststat, {
-                    Completed() {
-                        UtilLogger_1.SLogger.info(`第 ${currObj.index + 1} 次 repeatPromise 成功`);
+                const postresult = currObj.result;
+                const result = (0, QuickFunction_1.match)(postresult.stat, {
+                    [UtilSymbol_1.Completed]() {
+                        UtilLogger_1.SLogger.info(`第 ${postresult.index + 1} 次 repeatPromise 成功`);
                         //非当前
-                        if (currObj.index != i)
+                        if (postresult.index != i)
                             UtilLogger_1.SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
-                        return currObj.result;
+                        return postresult.result;
                     },
-                    Terminated() {
-                        UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 终止 停止重试`);
-                        return currObj.result;
+                    [UtilSymbol_1.Terminated]() {
+                        UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 repeatPromise 终止 停止重试`);
+                        return postresult.result;
                     },
-                    Failed() {
+                    [UtilSymbol_1.Failed]() {
                         //抛弃失败
-                        plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                        plist[postresult.index] = UtilFunc.getNeverResolvedPromise();
                         //是当前
-                        if (currObj.index == i) {
-                            UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 失败 开始重试`);
-                            clearTimer();
+                        if (postresult.index == i) {
+                            UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 repeatPromise 失败 开始重试`);
                             i++;
-                            return;
+                            return UtilSymbol_1.None;
                         }
                         //非当前
-                        UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 失败`);
+                        UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 repeatPromise 失败`);
+                        return UtilSymbol_1.None;
                     },
                 });
-                if (result !== undefined)
+                if (result !== UtilSymbol_1.None)
                     return result;
             }
             //全部失败或超时则返回null
@@ -219,13 +199,35 @@ var UtilFunc;
             UtilLogger_1.SLogger.warn(`repeatPromise 发生错误`, err);
             return null;
         }
-        finally {
-            //清理
-            clearTimer();
-            UtilLogger_1.SLogger.timeEnd(timeflag);
-        }
     }
-    UtilFunc.repeatPromise = repeatPromise;
+    /**创建一个限时的Promise
+     * @param func      - 处理函数
+     * @param timeLimit - 毫秒限时
+     * @returns 超时则返回 处理函数委托 完成则返回结果
+     */
+    static timelimitPromise(func, timeLimit) {
+        return new Promise((reslove) => {
+            let clearTimer = null;
+            let proc = (async () => await func())();
+            const procerP = new Promise(async (resolve) => {
+                const res = await proc;
+                if (clearTimer)
+                    clearTimer();
+                resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Completed, res));
+            });
+            const timerP = timeLimit
+                ? new Promise((resolve) => {
+                    const timer = setTimeout(() => resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Timeout, proc)), timeLimit); //无限制则无限时间
+                    clearTimer = () => {
+                        resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Timeout, proc));
+                        clearInterval(timer);
+                    };
+                })
+                : UtilFunc.getNeverResolvedPromise();
+            const result = Promise.race([procerP, timerP]);
+            reslove(result);
+        });
+    }
     /**部分类组合
      * 将mixin的部分字段混入base
      * @param base   - 基础类
@@ -234,7 +236,7 @@ var UtilFunc;
      * @param fields - 需要混入的字段
      * @returns 混合完成的类
      */
-    function composeClassPart(base, mixin, key, ...fields) {
+    static composeClassPart(base, mixin, key, ...fields) {
         const compObj = base;
         if (compObj[key] !== undefined)
             UtilLogger_1.SLogger.warn(`key: ${key} 已存在于基础类中, 混入可能导致类型问题`);
@@ -266,9 +268,8 @@ var UtilFunc;
         }
         return compObj;
     }
-    UtilFunc.composeClassPart = composeClassPart;
     /**根据 MIXIN_FIELDS 自动混入 */
-    function composeMixinable(base, ...mixins) {
+    static composeMixinable(base, ...mixins) {
         let out = base;
         const fieldsSet = new Set();
         for (const rawmixin of mixins) {
@@ -280,51 +281,37 @@ var UtilFunc;
                 else
                     fieldsSet.add(fixField);
             }
-            out = composeClassPart(base, mixin, mixin.MIXIN_KEY, ...mixin.MIXIN_FIELDS);
+            out = UtilFunc.composeClassPart(base, mixin, mixin.MIXIN_KEY, ...mixin.MIXIN_FIELDS);
         }
         return out;
     }
-    UtilFunc.composeMixinable = composeMixinable;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象
      * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
-    function mapEntries(obj, mapper) {
+    static mapEntries(obj, mapper) {
         return Object.entries(obj).reduce((result, [key, value]) => {
             result[key] = mapper(key, value);
             return result;
         }, {});
     }
-    UtilFunc.mapEntries = mapEntries;
-    /**处理联合 Outcome
-     * @param t       - 目标值
-     * @param procObj - 所有可能的id组成的处理函数映射
-     * @returns 任意处理函数的返回值
-     */
-    function matchOutcome(t, procObj) {
-        return procObj[t.status](t.status, t?.result);
-    }
-    UtilFunc.matchOutcome = matchOutcome;
-    /**处理联合 字符串
-     * @param t       - 目标值
-     * @param procObj - 所有可能的id组成的处理函数映射
-     * @returns 任意处理函数的返回值
-     */
-    function matchStr(t, procObj) {
-        return procObj[t](t);
-    }
-    UtilFunc.matchStr = matchStr;
     /**将JToken转换为字符串
      * @param token - 待转换的Token
      * @param space - 插入的空格 数字为空格数量 默认为制表符\t
      * @returns 转换完成的字符串
      */
-    function stringifyJToken(token, space = "\t") {
+    static stringifyJToken(token, space = "\t") {
         if (space == null)
             space = undefined;
         return JSON.stringify(token, null, space);
     }
-    UtilFunc.stringifyJToken = stringifyJToken;
-})(UtilFunc = exports.UtilFunc || (exports.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,3 +1,4 @@
+import { Completed, Failed, Terminated } from "./UtilSymbol";
 /**可以序列化为JSON文件的对象 */
 export type JToken = JObject | JArray | JValue | IJData;
 /**在stringify输出时 undefine 会被转为 null */
@@ -14,6 +15,8 @@ export interface IJData {
      */
     toJSON(): JToken;
 }
+/**任意可作为键值的类型 */
+export type Keyable = string | number | symbol;
 /**转为可写的 */
 export type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
@@ -53,7 +56,7 @@ export type ExclusiveJObject<B extends JObject, T extends JToken, K extends stri
  * 终止 将直接返回  null
  * 失败 将重试
  */
-export type PromiseStat = "Completed" | "Failed" | "Terminated";
+export type PromiseStat = Completed | Failed | Terminated;
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj: T) => Promise<PromiseStat> | PromiseStat;
 /**类型中任意函数的字符串名称 */
@@ -107,12 +110,12 @@ export type WithPrefix<T, P extends string> = {
  * @template K - 类型键值
  * @template V - 值
  */
-export type Outcome<K extends string, V> = {
+export type Outcome<K extends Keyable, V> = {
     /**状态类型 */
     status: K;
     /**值 */
     result: V;
 };
 /**从联合 Outcome 中 根据 id 提取对应 value 的 type */
-export type ExtractOutcome<T, K extends string> = T extends Outcome<K, unknown> ? T : never;
+export type ExtractOutcome<T, K extends Keyable> = T extends Outcome<K, unknown> ? T : never;
 export {};

package/dist/UtilSymbol.d.ts

@@ -0,0 +1,15 @@
+/**完成 */
+export declare const Completed: unique symbol;
+export type Completed = typeof Completed;
+/**失败 */
+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;
+/**超时 */
+export declare const Timeout: unique symbol;
+export type Timeout = typeof Timeout;

package/dist/UtilSymbol.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timeout = exports.None = exports.Terminated = exports.Failed = exports.Completed = void 0;
+/**完成 */
+exports.Completed = Symbol("Completed");
+/**失败 */
+exports.Failed = Symbol("Failed");
+/**终止 */
+exports.Terminated = Symbol("Terminated");
+/**不存在 */
+exports.None = Symbol("None");
+/**超时 */
+exports.Timeout = Symbol("Timeout");

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './UtilFunctions';
 export * from './UtilInterfaces';
+export * from './UtilSymbol';
 export * from './UtilClass';
 export * from './UtilCom';
 export * from './UtilCodecs';
@@ -8,3 +9,4 @@ export * from './UtilDecorators';
 export * from './UtilFileTools';
 export * from './UtilLogger';
 export * from './UtilFP';
+export * from './QuickFunction';

package/dist/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./UtilFunctions"), exports);
 __exportStar(require("./UtilInterfaces"), exports);
+__exportStar(require("./UtilSymbol"), exports);
 __exportStar(require("./UtilClass"), exports);
 __exportStar(require("./UtilCom"), exports);
 __exportStar(require("./UtilCodecs"), exports);
@@ -24,3 +25,4 @@ __exportStar(require("./UtilDecorators"), exports);
 __exportStar(require("./UtilFileTools"), exports);
 __exportStar(require("./UtilLogger"), exports);
 __exportStar(require("./UtilFP"), exports);
+__exportStar(require("./QuickFunction"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zwa73/utils",
-  "version": "1.0.77",
+  "version": "1.0.78",
   "description": "my utils",
   "main": "index.js",
   "scripts": {

package/src/QuickFunction.ts

@@ -0,0 +1,36 @@
+import { ExtractOutcome, Keyable, Outcome } from "./UtilInterfaces";
+
+/**创建一个outcome */
+export function outcome<K extends Keyable,V> (key:K,value:V):Outcome<K,V>{
+    return {status:key,result:value}
+}
+
+/**处理联合 简单值
+ * @param t       - 目标值
+ * @param procObj - 所有可能的id组成的处理函数映射
+ * @returns 任意处理函数的返回值
+ */
+export 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 {
+    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 a:"asd"|"dsa" = null as any;
+    const r = match(a,{
+        "asd":(a)=>"ssa" as const,
+        "dsa":(b)=>"ssb" as const,
+    })
+}
+

package/src/UtilDecorators.ts

@@ -1,3 +1,4 @@
+import { UtilFunc } from "./UtilFunctions";
 import { SLogger } from "./UtilLogger";
 
 type TDTg<T> = 
@@ -6,6 +7,41 @@ type TDTg<T> =
 type DTg = (target:Object, propertyKey:string, descriptor:PropertyDescriptor)=>
     PropertyDescriptor;
 
+/**用于打印方法运行时间  
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+export function LogTime(flag:string,suffixUID?:boolean):DTg{
+    return function (target, propertyKey, descriptor){
+        const originalMethod = descriptor.value;
+        descriptor.value = function(...args:any[]){
+            const uid = suffixUID ? UtilFunc.genUUID() : "";
+            SLogger.time(flag+uid);
+            let result = originalMethod.apply(this, args);
+            SLogger.timeEnd(flag+uid);
+            return result;
+        }
+        return descriptor;
+    }
+}
+/**用于打印异步方法运行时间  
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+export function LogTimeAsync(flag:string,suffixUID?:boolean):DTg{
+    return function (target, propertyKey, descriptor){
+        const originalMethod = descriptor.value;
+        descriptor.value = async function(...args:any[]){
+            const uid = suffixUID ? UtilFunc.genUUID() : "";
+            SLogger.time(flag+uid);
+            let result = await originalMethod.apply(this, args);
+            SLogger.timeEnd(flag+uid);
+            return result;
+        }
+        return descriptor;
+    }
+}
+
 /**用于打印方法的调用 */
 export function LogCall():DTg{
     return function (target, propertyKey, descriptor){
@@ -162,7 +198,7 @@ class Example {
     }
     @LogCall()
     @Defer((a,b)=>null)
-    async myMethod1(num: number,ss:string) {
+    static async myMethod1(num: number,ss:string) {
         return 312;
     }
 }

package/src/UtilFunctions.ts

@@ -1,14 +1,31 @@
 import * as crypto from "crypto";
-import { ComposedClass, ComposedMixinable, ExtractOutcome, FuncPropNames, IJData, JObject, JToken, Mixinable, Outcome, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
+import { ComposedClass, ComposedMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Mixinable, Outcome, PromiseStat, PromiseVerifyFn } 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";
 
+
+type CompleteCome<T> = Outcome<Completed,T>;
+type TimeoutCome<T> = Outcome<Timeout,Promise<T>>;
+/**永不完成的Promise单例 */
+const NeverResolvedPromise = new Promise(()=>{});
+/**进行中的请求 */
+type ProcessingPromise<T> = {
+    /**主体请求 */
+    result:T;
+    /**请求状态 */
+    stat:PromiseStat;
+    /**请求下标/序号 */
+    index:number;
+};
 /**常用函数 */
-export namespace UtilFunc{
+export class UtilFunc{
 /**获取当前时间戳  
  * @returns 时间戳
  */
-export function getTime(): number {
+static getTime(): number {
     return new Date().getTime();
 }
 
@@ -19,7 +36,7 @@ export function getTime(): number {
  * @param defaultVal - 默认值
  * @returns 最终值
  */
-export function initField<T extends object,K extends keyof T>(
+static initField<T extends object,K extends keyof T>(
     obj: T,
     field: K,
     defaultVal: T[K]
@@ -33,7 +50,7 @@ export function initField<T extends object,K extends keyof T>(
  * @param checkObj  - 用于检测的对象 在对应key缺失时赋予对应值 如果值为函数, 则赋予执行结果 如果结果为 undefined 则不赋值
  * @returns 完成初始化的对象
  */
-export function initObject<T extends JObject>
+static initObject<T extends JObject>
     (obj:T,checkObj:{[P in keyof T]:T[P]|(()=>void|T[P])}){
     const fixobj = obj as any;
     for(const key in checkObj){
@@ -52,14 +69,14 @@ export function initObject<T extends JObject>
 /**生成一串uuid  
  * @returns uuid
  */
-export function genUUID() {
+static genUUID() {
     return crypto.randomBytes(16).toString("hex");
 }
 /**计算Hash  
  * @param str - 待计算的字符串
  * @returns hash
  */
-export function calcHash(str:string) {
+static calcHash(str:string) {
     return crypto.createHash('md5').update(str).digest('hex');
 }
 
@@ -68,7 +85,7 @@ export function calcHash(str:string) {
  * @param obj  - 克隆目标
  * @returns 克隆结果
  */
-export function deepClone<T extends JToken>(obj: T): T {
+static deepClone<T extends JToken>(obj: T): T {
     return JSON.parse(JSON.stringify(obj));
 }
 
@@ -76,7 +93,7 @@ export function deepClone<T extends JToken>(obj: T): T {
  * @param num - 所要检测的数字
  * @returns 是否安全
  */
-export function isSafeNumber(num: number): boolean {
+static isSafeNumber(num: number): boolean {
     if (num === undefined || num == null || isNaN(num)) return false;
     if(typeof num === 'number') return true;
     return false;
@@ -87,10 +104,18 @@ export function isSafeNumber(num: number): boolean {
  * @param timeMs - 等待的毫秒数
  * @returns
  */
-export async function sleep(timeMs: number): Promise<boolean> {
+static async sleep<T>(timeMs: number): Promise<void>
+/**等待 timeMs 毫秒  
+ * @async
+ * @param timeMs - 等待的毫秒数
+ * @param result - 结果
+ * @returns
+ */
+static async sleep<T>(timeMs: number, result:T): Promise<T>
+static async sleep<T>(timeMs: number, result?:T): Promise<T|undefined> {
     return new Promise(function (resolve, rejecte) {
         let timer = setTimeout(function () {
-            resolve(true);
+            resolve(result);
         }, timeMs);
     });
 }
@@ -98,7 +123,7 @@ export async function sleep(timeMs: number): Promise<boolean> {
 /**封装的 cp.exec 执行一段指令 指令完成后返回 Promise  
  * @param command 指令文本
  */
-export function exec(command: string) {
+static exec(command: string) {
 	return new Promise<{ stdout:string, stderr:string }>
         ((resolve, reject) => {
 		cp.exec(command, (error, stdout, stderr) => {
@@ -110,23 +135,12 @@ export function exec(command: string) {
 	});
 }
 
-/**永不完成的Promise单例 */
-const NeverResolvedPromise = new Promise(()=>{});
+
 /**获得一个永不完成的Promise单例 */
-export function getNeverResolvedPromise<T>():Promise<T>{
+static getNeverResolvedPromise<T>():Promise<T>{
     return NeverResolvedPromise as Promise<T>;
 }
 
-/**进行中的请求 */
-type ProcessingPromise<T> = {
-    /**主体请求 */
-    result:T;
-    /**请求状态 */
-    stat:PromiseStat|Promise<PromiseStat>;
-    /**请求下标/序号 */
-    index:number;
-};
-
 /**重复尝试promise  
  * @async
  * @param procFn      - 发起函数
@@ -135,13 +149,10 @@ type ProcessingPromise<T> = {
  * @param repeatTime  - 超时时间/秒  最小为10秒
  * @returns 结果 null 为全部失败/超时
  */
-export async function repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>,
+@LogTimeAsync("repeatPromise ",true)
+static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>,
     repeatCount:number=3,repeatTime:number=180):Promise<T|null>{
 
-    //计时
-    const timeflag = "repeatPromise "+UtilFunc.genUUID();
-    SLogger.time(timeflag);
-
     /**是否含有超时时间 */
     const hasRepeatTime = (repeatTime>=10);
     //转换为毫秒
@@ -149,23 +160,13 @@ export async function repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVe
 
     //验证处理函数
     if(verifyFn===undefined)
-        verifyFn = ()=>"Completed";
-
-    /**计时器 */
-    let timer:NodeJS.Timer|null = null;
-    /**计时器 Promise */
-    let timerP:Promise<"Timeout">|null=null;
-    /**计时器 Promise 的返回函数 */
-    let resolveFn:((value: "Timeout")=>void)|null = null;
-    /**清理计时器 */
-    const clearTimer = ()=>{
-        if(timer) clearInterval(timer);
-        if(resolveFn) resolveFn("Timeout");
-        timerP = timer = resolveFn = null;
-    }
+        verifyFn = ()=>Completed;
 
     //进行中的请求
-	const plist:Promise<ProcessingPromise<T>>[] = [];
+	const plist:Promise<
+        CompleteCome<ProcessingPromise<T>>|
+        TimeoutCome<ProcessingPromise<T>>
+    >[] = [];
 
     //开始处理
     try{
@@ -175,57 +176,57 @@ export async function repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVe
 
             //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){
-                plist.push(procFn().then(result =>
-                    ({result, stat:verifyFn!(result), index:i})));
-            }
-
-            //创建定时器
-            if(timerP==null){
-                timerP = new Promise<"Timeout">((resolve, rejecte)=>{
-                    resolveFn = resolve;
-                    timer = setTimeout(()=>resolve("Timeout"),
-                        hasRepeatTime ? repeatTime : Infinity);//无限制则无限时间
-                })
+                plist.push(UtilFunc.timelimitPromise<ProcessingPromise<T>>(async ()=>{
+                    const result = await procFn();
+                    const stat = await verifyFn!(result);
+                    return {result, stat, index:i}
+                }));
             }
 
             //等待任意任务 或当前计时器完成
-            const currObj = await Promise.race([...plist, timerP]);
+            const currObj = await Promise.race([...plist]);
 
             //超时处理
-            if(currObj==="Timeout"){
+            if(currObj.status===Timeout){
+                //解除timeout替换原参数
+                plist[i]=new Promise(async (rslove)=>{
+                    const res = await currObj.result;
+                    rslove(outcome(Completed,res));
+                })
                 SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
-                clearTimer(); i++;
+                i++;
                 continue;
             }
 
             //路由请求状态
-            const poststat = await currObj.stat;
-            const result = matchStr(poststat,{
-                Completed(){
-                    SLogger.info(`第 ${currObj.index+1} 次 repeatPromise 成功`);
+            const postresult = currObj.result;
+            const result = match(postresult.stat,{
+                [Completed](){
+                    SLogger.info(`第 ${postresult.index+1} 次 repeatPromise 成功`);
                     //非当前
-                    if(currObj.index!=i)
+                    if(postresult.index!=i)
                         SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
-                    return currObj.result;
+                    return postresult.result;
                 },
-                Terminated(){
-                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 终止 停止重试`);
-                    return currObj.result;
+                [Terminated](){
+                    SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 终止 停止重试`);
+                    return postresult.result;
                 },
-                Failed(){
+                [Failed]():None{
                     //抛弃失败
-                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                    plist[postresult.index] = UtilFunc.getNeverResolvedPromise();
                     //是当前
-                    if(currObj.index==i){
-                        SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败 开始重试`);
-                        clearTimer(); i++;
-                        return;
+                    if(postresult.index==i){
+                        SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 失败 开始重试`);
+                        i++;
+                        return None;
                     }
                     //非当前
-                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败`);
+                    SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 失败`);
+                    return None;
                 },
             });
-            if(result !== undefined) return result;
+            if(result !== None) return result;
         }
         //全部失败或超时则返回null
         SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
@@ -233,13 +234,47 @@ export async function repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVe
     }catch(err){
         SLogger.warn(`repeatPromise 发生错误`,err);
         return null;
-    }finally{
-        //清理
-        clearTimer();
-        SLogger.timeEnd(timeflag);
     }
 }
 
+
+/**创建一个限时的Promise  
+ * @param func      - 处理函数
+ * @param timeLimit - 毫秒限时
+ * @returns 超时则返回 处理函数委托 完成则返回结果
+ */
+static timelimitPromise<T>
+    (func:()=>Promise<T>|T,timeLimit?:number):Promise<CompleteCome<T>|TimeoutCome<T>>{
+    return new Promise<CompleteCome<T>|TimeoutCome<T>>((reslove)=>{
+        let clearTimer:(()=>void)| null = null;
+        let proc = (async ()=>await func())();
+
+        const procerP = new Promise<CompleteCome<T>>(async (resolve)=>{
+            const res = await proc;
+            if(clearTimer) clearTimer();
+            resolve(outcome(Completed,res))
+        });
+
+        const timerP = timeLimit
+            ? new Promise<TimeoutCome<T>>((resolve)=>{
+                const timer = setTimeout(()=>
+                    resolve(outcome(Timeout,proc))
+                ,timeLimit);//无限制则无限时间
+
+                clearTimer = ()=>{
+                    resolve(outcome(Timeout,proc))
+                    clearInterval(timer)
+                }
+            })
+            : UtilFunc.getNeverResolvedPromise<TimeoutCome<T>>();
+
+        const result = Promise.race([procerP,timerP]);
+        reslove(result);
+    })
+}
+
+
+
 /**部分类组合  
  * 将mixin的部分字段混入base  
  * @param base   - 基础类
@@ -248,7 +283,7 @@ export async function repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVe
  * @param fields - 需要混入的字段
  * @returns 混合完成的类
  */
-export function composeClassPart
+static composeClassPart
     <Base extends object,Mixin extends object,Field extends keyof Mixin>
     (base:Base,mixin:Mixin,key:string,...fields:Field[]):ComposedClass<Base,Mixin,typeof key,Field>{
     const compObj = base as any;
@@ -283,7 +318,7 @@ export function composeClassPart
 }
 
 /**根据 MIXIN_FIELDS 自动混入 */
-export function composeMixinable
+static composeMixinable
     <Base extends object, Mixins extends Mixinable<any>[]>
     (base:Base,...mixins:Mixins):
     ComposedMixinable<Base,Mixins>{
@@ -298,7 +333,7 @@ export function composeMixinable
             else
                 fieldsSet.add(fixField);
         }
-        out = composeClassPart(base,mixin,mixin.MIXIN_KEY,...mixin.MIXIN_FIELDS);
+        out = UtilFunc.composeClassPart(base,mixin,mixin.MIXIN_KEY,...mixin.MIXIN_FIELDS);
     }
     return out as any;
 }
@@ -310,7 +345,7 @@ export function composeMixinable
  * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
  * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
  */
-export function 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);
@@ -318,33 +353,12 @@ export function mapEntries<T extends Object>
     }, {} as T);
 }
 
-/**处理联合 Outcome
- * @param t       - 目标值
- * @param procObj - 所有可能的id组成的处理函数映射
- * @returns 任意处理函数的返回值
- */
-export function matchOutcome<
-    T extends Outcome<string,unknown>,
-    P extends {[K in T['status']]:(k:K,v:ExtractOutcome<T,K>['result'])=>unknown}>
-    (t:T,procObj:P):{[K in keyof P]:ReturnType<P[K]>}[keyof P]{
-    return (procObj as any)[t.status](t.status,(t as any)?.result)
-}
-/**处理联合 字符串
- * @param t       - 目标值
- * @param procObj - 所有可能的id组成的处理函数映射
- * @returns 任意处理函数的返回值
- */
-export function matchStr<T extends string,P extends {[K in T]:(k:K)=>unknown}>
-    (t:T,procObj:P):{[K in keyof P]:ReturnType<P[K]>}[keyof P]{
-        return (procObj as any)[t](t)
-}
-
 /**将JToken转换为字符串
  * @param token - 待转换的Token
  * @param space - 插入的空格 数字为空格数量 默认为制表符\t
  * @returns 转换完成的字符串
  */
-export function stringifyJToken(token:JToken|IJData,space:string|number|null|undefined="\t"){
+static stringifyJToken(token:JToken|IJData,space:string|number|null|undefined="\t"){
 	if(space==null)
 		space=undefined;
 	return JSON.stringify(token,null,space);

package/src/UtilInterfaces.ts

@@ -1,3 +1,4 @@
+import { Completed, Failed, Terminated } from "./UtilSymbol";
 
 
 /**可以序列化为JSON文件的对象 */
@@ -17,6 +18,9 @@ export interface IJData{
 	toJSON():JToken;
 }
 
+/**任意可作为键值的类型 */
+export type Keyable = string | number | symbol;
+
 /**转为可写的 */
 export type Writeable<T> = {
 	-readonly [P in keyof T]: T[P]
@@ -67,7 +71,7 @@ export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string
  * 终止 将直接返回  null  
  * 失败 将重试  
  */
-export type PromiseStat = "Completed"|"Failed"|"Terminated";
+export type PromiseStat = Completed|Failed|Terminated;
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj:T)=>Promise<PromiseStat>|PromiseStat;
 
@@ -139,7 +143,7 @@ export type WithPrefix<T,P extends string> = {
  * @template K - 类型键值
  * @template V - 值
  */
-export type Outcome<K extends string,V> = {
+export type Outcome<K extends Keyable,V> = {
     /**状态类型 */
     status:K;
     /**值 */
@@ -147,6 +151,6 @@ export type Outcome<K extends string,V> = {
 }
 
 /**从联合 Outcome 中 根据 id 提取对应 value 的 type */
-export type ExtractOutcome<T,K extends string> =
+export type ExtractOutcome<T,K extends Keyable> =
     T extends Outcome<K,unknown> ? T : never;
 

package/src/UtilSymbol.ts

@@ -0,0 +1,15 @@
+/**完成 */
+export const Completed = Symbol("Completed");
+export type Completed = typeof Completed;
+/**失败 */
+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;
+/**超时 */
+export const Timeout = Symbol("Timeout");
+export type Timeout = typeof Timeout;

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './UtilFunctions';
 export * from './UtilInterfaces';
+export * from './UtilSymbol';
 export * from './UtilClass';
 export * from './UtilCom';
 export * from './UtilCodecs';
@@ -7,4 +8,5 @@ export * from './UtilFfmpegTools';
 export * from './UtilDecorators';
 export * from './UtilFileTools';
 export * from './UtilLogger';
-export * from './UtilFP';
+export * from './UtilFP';
+export * from './QuickFunction';