@zwa73/utils 1.0.164 → 1.0.166

package/dist/UtilClass.d.ts

@@ -1,4 +1,5 @@
-import { Literal } from "./UtilInterfaces";
+import { Keyable, Literal } from "./UtilInterfaces";
+import Handlebars from 'handlebars';
 /**函数管道器 */
 export declare class Piper<Arg, Result = Arg> {
     /**管道函数列表 */
@@ -69,4 +70,20 @@ export declare class Stream<T> implements Iterable<T> {
     [Symbol.iterator](): Iterator<T>;
     get length(): number;
 }
+/**文本模板渲染器
+ * @template T - 上下文对象的类型，默认为记录类型
+ */
+export declare class Hbs<T extends Record<Keyable, any> = Record<Keyable, any>> {
+    hbs: typeof Handlebars;
+    context: T;
+    /**创建一个新的 Hbs 实例
+    * @param context - 上下文对象，用于在渲染模板时提供数据
+    */
+    constructor(context?: T);
+    /**渲染模板
+     * @param template - 要渲染的 Handlebars 模板字符串
+     * @returns 渲染后的字符串
+     */
+    render(template: string): string;
+}
 export {};

package/dist/UtilClass.js

@@ -1,7 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Stream = exports.Piper = void 0;
+exports.Hbs = exports.Stream = exports.Piper = void 0;
 const QuickFunction_1 = require("./QuickFunction");
+const handlebars_1 = __importDefault(require("handlebars"));
+const UtilLogger_1 = require("./UtilLogger");
 /**函数管道器 */
 class Piper {
     /**管道函数列表 */
@@ -188,3 +193,44 @@ class Stream {
     }
 }
 exports.Stream = Stream;
+/**文本模板渲染器
+ * @template T - 上下文对象的类型，默认为记录类型
+ */
+class Hbs {
+    hbs = handlebars_1.default.create();
+    context;
+    /**创建一个新的 Hbs 实例
+    * @param context - 上下文对象，用于在渲染模板时提供数据
+    */
+    constructor(context = {}) {
+        this.context = context;
+        this.hbs.registerHelper('def', (name, options) => {
+            const value = options.fn(this.context).trim();
+            this.context[name] = value;
+            return '';
+        });
+        this.hbs.registerHelper('defli', (name, options) => {
+            const rawvalue = options.fn();
+            const values = rawvalue
+                .split('[[br]]')
+                .map(value => value.trim())
+                .map(value => this.hbs.compile(value)(this.context));
+            this.context[name] = values;
+            return '';
+        });
+    }
+    /**渲染模板
+     * @param template - 要渲染的 Handlebars 模板字符串
+     * @returns 渲染后的字符串
+     */
+    render(template) {
+        try {
+            return this.hbs.compile(template)(this.context);
+        }
+        catch (e) {
+            UtilLogger_1.SLogger.error(e);
+            return '';
+        }
+    }
+}
+exports.Hbs = Hbs;

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { PRecord, AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqVerifyFn, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await, AnyRecord, AllExtends } from "./UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends } from "./UtilInterfaces";
 import { LogLevel } from "./UtilLogger";
 import { Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Timeout } from "./UtilSymbol";
 declare const HashMethodList: readonly ["md5", "sha1", "sha256", "sha512", "sha3", "blake2", "blake3"];
@@ -117,21 +117,6 @@ export declare class UtilFunc {
      * @returns 超时则返回 处理函数委托 完成则返回结果
      */
     static timelimitPromise<T>(func: () => Promise<T> | T, timeLimit?: number): Promise<SuccessOut<T> | TimeoutOut<T>>;
-    /**部分类组合
-     * 将mixin的部分字段混入base
-     * @param base   - 基础类
-     * @param mixin  - 目标类
-     * @param key    - mixin 对象在 base 中的 key
-     * @param fields - 需要混入的字段
-     * @returns 混合完成的类
-     */
-    static composeClassPart<Base extends AnyRecord, Mixin extends AnyRecord, Field extends keyof Mixin>(base: Base, mixin: Mixin, key: string, ...fields: Field[]): ComposedClass<Base, Mixin, typeof key, Field>;
-    /**根据 MIXIN_FIELDS 自动混入
-     * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
-     */
-    static composeMixinable<Base extends AnyRecord, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
-    /**根据 MIXIN_FIELDS 自动混入 */
-    static composeRefMixinable<Base extends AnyRecord, Mixins extends RefMixinable<any, unknown>[]>(base: Base, ...mixins: Mixins): ComposedRefMixinable<Base, Mixins>;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象
@@ -139,7 +124,7 @@ export declare class UtilFunc {
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
     static mapEntries<T extends AnyRecord>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
-    /** 遍历对象的所有字段
+    /**遍历对象的所有字段
      * @param obj       - 对象
      * @param callback  - 回调函数
      */
@@ -237,10 +222,6 @@ export declare class UtilFunc {
      * @returns 是否安全
      */
     static isSafeNumber(num: unknown): boolean;
-    /**将一个字段加入一个对象中，将改变对象，返回新类型 */
-    static bindTo<K extends Keyable, V, B extends AnyRecord = {}>(key: Literal<K>, value: V, base?: B): keyof B extends K ? "Base中已有对应键" & Error : {
-        [P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;
-    };
     /**移除多行字符串中每行开始的最小空格数。
      *
      * @param input   - 需要处理的多行 字符串模板 或 字符串。
@@ -284,7 +265,7 @@ export declare class UtilFunc {
      * @param func - 待转换函数
      * @returns 转换完成的函数
      */
-    static taskEitherize<T extends (...args: any) => Promise<any>>(func: T): (...args: Parameters<T>) => Promise<Outcome<typeof Failed, Error> | Outcome<typeof Success, Await<ReturnType<T>>>>;
+    static taskEitherize<T extends (...args: any) => Promise<any>>(func: T): (...args: Parameters<T>) => Promise<Outcome<typeof Failed, Error> | Outcome<typeof Success, Awaited<ReturnType<T>>>>;
     /**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。
      * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。
      * 请注意，这个函数使用了eval()，可能会带来安全风险。

package/dist/UtilFunctions.js

@@ -286,86 +286,6 @@ class UtilFunc {
             reslove(result);
         });
     }
-    /**部分类组合
-     * 将mixin的部分字段混入base
-     * @param base   - 基础类
-     * @param mixin  - 目标类
-     * @param key    - mixin 对象在 base 中的 key
-     * @param fields - 需要混入的字段
-     * @returns 混合完成的类
-     */
-    static composeClassPart(base, mixin, key, ...fields) {
-        const compObj = base;
-        if (compObj[key] !== undefined)
-            UtilLogger_1.SLogger.warn(`key: ${key} 已存在于基础类中, 混入可能导致类型问题`);
-        compObj[key] = mixin;
-        for (const fd of fields) {
-            if (compObj[fd] !== undefined)
-                UtilLogger_1.SLogger.warn(`field: ${fd} 已存在于基础类中, 混入可能导致类型问题, 如需覆盖, 请使用 ${key}=val`);
-            //func需绑定this无法直接设置属性
-            if (typeof mixin[fd] === 'function') {
-                compObj[fd] = (...args) => compObj[key][fd](...args);
-                //#region other
-                //const memo = (...args: any[]) => compObj[key][fd](...args);
-                //Object.defineProperty(compObj, fd, {
-                //    get:()=>memo,
-                //    set:()=>SLogger.warn(new Error(`试图修改一个由 composeClassPart 组合的函数字段:${String(fd)}, 修改已被忽略`)),
-                //    enumerable:true ,
-                //    //writable: true  ,
-                //    configurable: true
-                //});
-                //(compObj as any)[fd] = (...args: any[]) => (mixin[fd] as any).apply(mixin, args);
-                //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
-                //#endregion
-            }
-            else {
-                Object.defineProperty(compObj, fd, {
-                    get: () => compObj[key][fd],
-                    set: (value) => { compObj[key][fd] = value; },
-                    enumerable: true,
-                    //writable: true  ,
-                    configurable: true
-                });
-            }
-        }
-        return compObj;
-    }
-    /**根据 MIXIN_FIELDS 自动混入
-     * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
-     */
-    static composeMixinable(base, ...mixins) {
-        let out = base;
-        const fieldsSet = new Set();
-        for (const rawmixin of mixins) {
-            const mixin = rawmixin;
-            for (const field of mixin.MIXIN_FIELDS) {
-                const fixField = field;
-                if (fieldsSet.has(fixField))
-                    UtilLogger_1.SLogger.warn(`composeMixinable 出现了重复的 field: ${fixField} 可能会导致问题`);
-                else
-                    fieldsSet.add(fixField);
-            }
-            out = UtilFunc.composeClassPart(base, mixin, mixin.MIXIN_KEY, ...mixin.MIXIN_FIELDS);
-        }
-        return out;
-    }
-    /**根据 MIXIN_FIELDS 自动混入 */
-    static composeRefMixinable(base, ...mixins) {
-        let out = base;
-        const fieldsSet = new Set();
-        for (const mixin of mixins) {
-            const ctor = mixin.CTOR;
-            for (const field of ctor.MIXIN_FIELDS) {
-                const fixField = field;
-                if (fieldsSet.has(fixField))
-                    UtilLogger_1.SLogger.warn(`composeMixinable 出现了重复的 field: ${fixField} 可能会导致问题`);
-                else
-                    fieldsSet.add(fixField);
-            }
-            out = UtilFunc.composeClassPart(base, mixin, ctor.MIXIN_KEY, ...ctor.MIXIN_FIELDS);
-        }
-        return out;
-    }
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象
@@ -378,7 +298,7 @@ class UtilFunc {
             return result;
         }, {});
     }
-    /** 遍历对象的所有字段
+    /**遍历对象的所有字段
      * @param obj       - 对象
      * @param callback  - 回调函数
      */
@@ -623,13 +543,6 @@ class UtilFunc {
         }
         return false;
     }
-    /**将一个字段加入一个对象中，将改变对象，返回新类型 */
-    static bindTo(key, value, base) {
-        let out = base;
-        out = out ?? {};
-        out[key] = value;
-        return out;
-    }
     /**移除多行字符串中每行开始的最小空格数。
      *
      * @param input   - 需要处理的多行 字符串模板 或 字符串。

package/dist/UtilInterfaces.d.ts

@@ -101,63 +101,14 @@ export type ExclusiveJObject<B extends JObject, T extends JToken, K extends stri
 export type ReqStat = Success | Failed | Terminated;
 /**请求状态验证函数 */
 export type ReqVerifyFn<T> = (obj: T) => Promise<ReqStat> | ReqStat;
-/**获取Promise的结果类型 如同await那样 */
+/**获取Promise的结果类型 如同await那样
+ * @deprecated 请使用官方的 Awaited<T> 类型
+ */
 export type Await<T> = T extends Promise<infer U> ? U : T;
 /**类型中任意函数的字符串名称 */
 export type FuncPropNames<T> = {
     [K in keyof T]: T[K] extends AnyFunc ? K : never;
 }[keyof T];
-/**部分组合的类
- * @template Base     - 基类
- * @template Mixin    - 待混入的类
- * @template PropKeys - 需要混入的成员key
- */
-export type ComposedClass<Base, Mixin, Key extends string, PropKeys extends keyof Mixin> = Base & Pick<Mixin, PropKeys> & {
-    [P in Key]: Mixin;
-};
-/**可自动混入的类型 */
-export type Mixinable<Mixin> = {
-    /**混入时自身所在位置
-     * 请使用字面量
-     */
-    readonly MIXIN_KEY: string;
-    /**可混入的字段
-     * 请使用字面量
-    */
-    readonly MIXIN_FIELDS: readonly (keyof Mixin)[];
-};
-/**是原型构造器类型 */
-export type IsCtor<T> = T extends {
-    new (): infer Ins;
-} ? T : never;
-/**可反射的
- * @template Ctor        - 构造器类型
- * @template Constraint  - 构造器约束
- */
-export type ReflectionAble<Ctor, Constraint = {}> = {
-    /**原型构造器 */
-    readonly CTOR: Ctor & Constraint;
-};
-/**可反射的 且 构造函数是可混入的类
- * @template Ctor        - 构造器类型
- * @template Instance    - 实例类型 如果采用了内部混入, 那么填入对外实际暴露的类型, 以支持混入多层字段
- * @template Constraint  - 构造器约束
- * @example
- * export class MixinModule implements RefMixinable<typeof MixinModule,MixinModule>{
- *   static readonly MIXIN_FIELDS = [
- *       'func_a',
- *       'field_b'
- *   ] as const;
- *   static readonly MIXIN_KEY = '__mixinModule';
- *   CTOR = MixinModule;
- * }
- */
-export type RefMixinable<Ctor, Instance, Constraint = {}> = ReflectionAble<Ctor, Mixinable<Instance> & Constraint>;
-/**自动组合可混入的类
- */
-export type ComposedMixinable<B, Ms extends unknown[]> = Ms extends [infer M, ...infer Rest] ? M extends Mixinable<M> ? ComposedMixinable<ComposedClass<B, M, M['MIXIN_KEY'], M['MIXIN_FIELDS'][number]>, Rest> : "一个混入类没有实现 Mixinable<self>" & Error : B;
-/**自动组合 可反射的 且 构造函数是可混入的 类 */
-export type ComposedRefMixinable<B, Ms extends unknown[]> = Ms extends [infer M, ...infer Rest] ? M extends RefMixinable<unknown, M> ? ComposedRefMixinable<ComposedClass<B, M, M['CTOR']['MIXIN_KEY'], M['CTOR']['MIXIN_FIELDS'][number]>, Rest> : "一个混入类没有实现  RefMixinable<typeof self, self>" & Error : B;
 /** extends封装
  * @template B - 基础类型
  * @template T - 判断的目标类型

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.164",
+	"version": "1.0.166",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {
@@ -19,6 +19,7 @@
 		"@deepkit/type": "^1.0.1-alpha.153",
 		"fluent-ffmpeg": "2.1.2",
 		"glob": "^10.4.1",
+		"handlebars": "^4.7.8",
 		"html-entities": "^2.3.3",
 		"http-proxy-agent": "^5.0.0",
 		"https-proxy-agent": "^5.0.1",

package/src/UtilClass.ts

@@ -1,5 +1,7 @@
 import { matchProc } from "./QuickFunction";
-import { Literal } from "./UtilInterfaces";
+import { Keyable, Literal } from "./UtilInterfaces";
+import Handlebars from 'handlebars';
+import { SLogger } from "./UtilLogger";
 
 /**函数管道器 */
 export class Piper<Arg, Result = Arg> {
@@ -194,4 +196,49 @@ export class Stream<T> implements Iterable<T>{
     get length(): number {
         return this._list.length;
     }
-}
+}
+
+/**文本模板渲染器
+ * @template T - 上下文对象的类型，默认为记录类型
+ */
+export class Hbs<T extends Record<Keyable,any> = Record<Keyable,any>>{
+    hbs = Handlebars.create();
+    context:T;
+
+    /**创建一个新的 Hbs 实例
+    * @param context - 上下文对象，用于在渲染模板时提供数据
+    */
+    constructor(context:T={} as T) {
+        this.context = context;
+
+        this.hbs.registerHelper('def', (name, options)=> {
+            const value = options.fn(this.context).trim();
+            (this.context as any)[name] = value;
+            return '';
+        });
+
+        this.hbs.registerHelper('defli', (name,options)=> {
+            const rawvalue = options.fn() as string;
+
+            const values = rawvalue
+                .split('[[br]]')
+                .map(value => value.trim())
+                .map(value => this.hbs.compile(value)(this.context));
+            (this.context as any)[name] = values;
+            return '';
+        });
+    }
+
+    /**渲染模板
+     * @param template - 要渲染的 Handlebars 模板字符串
+     * @returns 渲染后的字符串
+     */
+    render(template:string):string{
+        try{
+            return this.hbs.compile(template)(this.context);
+        } catch(e){
+            SLogger.error(e);
+            return '';
+        }
+    }
+}

package/src/UtilDecorators.ts

@@ -1,5 +1,5 @@
 import { UtilFunc } from "./UtilFunctions";
-import { Await, NeedInit } from "./UtilInterfaces";
+import { NeedInit } from "./UtilInterfaces";
 import { SLogger } from "./UtilLogger";
 
 type TDTg<T> = 

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { PRecord, AnyFunc, ComposedClass, ComposedMixinable, ComposedRefMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Mixinable, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, RefMixinable, UnionToIntersection, Await, AnyRecord, AllExtends } from "@src/UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends } from "@src/UtilInterfaces";
 import * as cp from "child_process";
 import { LogLevel, SLogger } from "@src/UtilLogger";
 import { Completed, Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Terminated, Timeout } from "./UtilSymbol";
@@ -347,99 +347,6 @@ static timelimitPromise<T>
     })
 }
 
-
-
-/**部分类组合  
- * 将mixin的部分字段混入base  
- * @param base   - 基础类
- * @param mixin  - 目标类
- * @param key    - mixin 对象在 base 中的 key
- * @param fields - 需要混入的字段
- * @returns 混合完成的类
- */
-static composeClassPart
-    <Base extends AnyRecord,Mixin extends AnyRecord,Field extends keyof Mixin>
-    (base:Base,mixin:Mixin,key:string,...fields:Field[]):ComposedClass<Base,Mixin,typeof key,Field>{
-    const compObj = base as any;
-    if(compObj[key]!==undefined)
-        SLogger.warn(`key: ${key as string} 已存在于基础类中, 混入可能导致类型问题`);
-    compObj[key] = mixin;
-    for(const fd of fields){
-        if(compObj[fd]!==undefined)
-            SLogger.warn(`field: ${fd as string} 已存在于基础类中, 混入可能导致类型问题, 如需覆盖, 请使用 ${key}=val`);
-        //func需绑定this无法直接设置属性
-        if(typeof mixin[fd] === 'function') {
-            compObj[fd] = (...args: any[]) => compObj[key][fd](...args);
-            //#region other
-            //const memo = (...args: any[]) => compObj[key][fd](...args);
-            //Object.defineProperty(compObj, fd, {
-            //    get:()=>memo,
-            //    set:()=>SLogger.warn(new Error(`试图修改一个由 composeClassPart 组合的函数字段:${String(fd)}, 修改已被忽略`)),
-            //    enumerable:true ,
-            //    //writable: true  ,
-            //    configurable: true
-            //});
-            //(compObj as any)[fd] = (...args: any[]) => (mixin[fd] as any).apply(mixin, args);
-            //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
-            //#endregion
-        } else {
-            Object.defineProperty(compObj, fd, {
-                get: ()=>compObj[key][fd],
-                set: (value)=>{compObj[key][fd] = value},
-                enumerable:true ,
-                //writable: true  ,
-                configurable: true
-            });
-        }
-    }
-    return compObj;
-}
-
-/**根据 MIXIN_FIELDS 自动混入  
- * @deprecated 非必要情况下, 对class定义请使用 composeRefMixinable
- */
-static composeMixinable
-    <Base extends AnyRecord, Mixins extends Mixinable<any>[]>
-    (base:Base,...mixins:Mixins):
-    ComposedMixinable<Base,Mixins>{
-    let out = base;
-    const fieldsSet = new Set<string>();
-    for(const rawmixin of mixins){
-        const mixin=rawmixin as any;
-        for(const field of mixin.MIXIN_FIELDS) {
-            const fixField = field as string;
-            if(fieldsSet.has(fixField))
-                SLogger.warn(`composeMixinable 出现了重复的 field: ${fixField} 可能会导致问题`);
-            else
-                fieldsSet.add(fixField);
-        }
-        out = UtilFunc.composeClassPart(base,mixin,mixin.MIXIN_KEY,...mixin.MIXIN_FIELDS);
-    }
-    return out as any;
-}
-
-/**根据 MIXIN_FIELDS 自动混入 */
-static composeRefMixinable
-    <Base extends AnyRecord, Mixins extends RefMixinable<any,unknown>[]>
-    (base:Base,...mixins:Mixins):
-    ComposedRefMixinable<Base,Mixins>{
-    let out = base;
-    const fieldsSet = new Set<string>();
-    for(const mixin of mixins){
-        const ctor = mixin.CTOR;
-        for(const field of ctor.MIXIN_FIELDS) {
-            const fixField = field as string;
-            if(fieldsSet.has(fixField))
-                SLogger.warn(`composeMixinable 出现了重复的 field: ${fixField} 可能会导致问题`);
-            else
-                fieldsSet.add(fixField);
-        }
-        out = UtilFunc.composeClassPart(base,mixin,ctor.MIXIN_KEY,...ctor.MIXIN_FIELDS);
-    }
-    return out as any;
-}
-
-
 /**对对象的每个属性应用映射函数，并返回一个新的对象。
  * @template T      - 对象的类型
  * @param obj       - 要处理的对象
@@ -454,7 +361,7 @@ static mapEntries<T extends AnyRecord>
     }, {} as T);
 }
 
-/** 遍历对象的所有字段
+/**遍历对象的所有字段
  * @param obj       - 对象
  * @param callback  - 回调函数
  */
@@ -744,16 +651,6 @@ static isSafeNumber(num: unknown): boolean {
     return false;
 }
 
-/**将一个字段加入一个对象中，将改变对象，返回新类型 */
-static bindTo<K extends Keyable, V, B extends AnyRecord = {}>
-    (key: Literal<K>,value: V, base?:B):keyof B extends K
-        ? "Base中已有对应键"&Error
-        : {[P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;}{
-    let out = base as any;
-    out = out??{};
-    out[key]=value;
-    return out;
-}
 /**移除多行字符串中每行开始的最小空格数。
  *
  * @param input   - 需要处理的多行 字符串模板 或 字符串。
@@ -847,7 +744,7 @@ static eitherize<T extends AnyFunc>(func:T) {
 static taskEitherize<T extends (...args:any)=>Promise<any>>(func:T) {
     return async (...args: Parameters<T>) => {
         try {
-            const result:Await<ReturnType<T>> = await func(...args as any);
+            const result:Awaited<ReturnType<T>> = await func(...args as any);
             return UtilFunc.outcome(Success,result);
         } catch (error) {
             if(error instanceof Error)

package/src/UtilInterfaces.ts

@@ -149,82 +149,17 @@ export type ReqStat = Success|Failed|Terminated;
 /**请求状态验证函数 */
 export type ReqVerifyFn<T> = (obj:T)=>Promise<ReqStat>|ReqStat;
 
-/**获取Promise的结果类型 如同await那样 */
+/**获取Promise的结果类型 如同await那样
+ * @deprecated 请使用官方的 Awaited<T> 类型
+ */
 export type Await<T> = T extends Promise<infer U> ? U : T;
 
+
 /**类型中任意函数的字符串名称 */
 export type FuncPropNames<T> = {
     [K in keyof T]: T[K] extends AnyFunc ? K : never;
 }[keyof T];
 
-/**部分组合的类 
- * @template Base     - 基类
- * @template Mixin    - 待混入的类
- * @template PropKeys - 需要混入的成员key
- */
-export type ComposedClass<Base, Mixin, Key extends string, PropKeys extends keyof Mixin> = 
-    Base & Pick<Mixin, PropKeys> & {[P in Key]:Mixin};
-
-/**可自动混入的类型 */
-export type Mixinable<Mixin> = {
-    /**混入时自身所在位置  
-     * 请使用字面量  
-     */
-    readonly MIXIN_KEY: string;
-    /**可混入的字段  
-     * 请使用字面量
-    */
-    readonly MIXIN_FIELDS: readonly (keyof Mixin)[];
-};
-/**是原型构造器类型 */
-export type IsCtor<T> = T extends {new():infer Ins}
-    ? T : never;
-/**可反射的  
- * @template Ctor        - 构造器类型
- * @template Constraint  - 构造器约束
- */
-export type ReflectionAble<Ctor,Constraint={}> = {
-    /**原型构造器 */
-    readonly CTOR:Ctor&Constraint
-};
-/**可反射的 且 构造函数是可混入的类  
- * @template Ctor        - 构造器类型
- * @template Instance    - 实例类型 如果采用了内部混入, 那么填入对外实际暴露的类型, 以支持混入多层字段
- * @template Constraint  - 构造器约束
- * @example
- * export class MixinModule implements RefMixinable<typeof MixinModule,MixinModule>{
- *   static readonly MIXIN_FIELDS = [
- *       'func_a',
- *       'field_b'
- *   ] as const;
- *   static readonly MIXIN_KEY = '__mixinModule';
- *   CTOR = MixinModule;
- * }
- */
-export type RefMixinable<Ctor,Instance,Constraint={}> =
-    ReflectionAble<Ctor,Mixinable<Instance>&Constraint>;
-
-
-/**自动组合可混入的类  
- */
-export type ComposedMixinable<B, Ms extends unknown[]> = 
-    Ms extends [infer M, ...infer Rest]
-        ? M extends Mixinable<M>
-            ? ComposedMixinable<ComposedClass<B,M,M['MIXIN_KEY'],M['MIXIN_FIELDS'][number]>,Rest>
-            : "一个混入类没有实现 Mixinable<self>" & Error
-        : B
-
-/**自动组合 可反射的 且 构造函数是可混入的 类 */
-export type ComposedRefMixinable<B, Ms extends unknown[]> = 
-    Ms extends [infer M, ...infer Rest]
-        ? M extends RefMixinable<unknown,M>
-            ? ComposedRefMixinable<ComposedClass<B,M,
-                M['CTOR']['MIXIN_KEY'],
-                M['CTOR']['MIXIN_FIELDS'][number]>,
-                Rest>
-            : "一个混入类没有实现  RefMixinable<typeof self, self>" & Error
-        : B
-
 /** extends封装  
  * @template B - 基础类型
  * @template T - 判断的目标类型