@zwa73/utils 1.0.46 → 1.0.49

package/src/UtilCom.ts

@@ -1,4 +1,4 @@
-import { JObject, ProcessingPromise, PromiseVerifyFn, stringifyJToken } from "./UtilInterfaces";
+import { JObject, PromiseVerifyFn, stringifyJToken } from "./UtilInterfaces";
 import * as https from 'https';
 import * as http from 'http';
 import { SLogger } from "./UtilLogger";
@@ -22,7 +22,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
         timeLimit*=1000
 
     const jsonStr = stringifyJToken(json);
-    const funcName = "s"+posttype+"Psot";
+    const funcName = `s${posttype}Psot`;
 
     return new Promise((resolve, rejecte)=>{
         const resFunc = (res:http.IncomingMessage)=>{
@@ -31,7 +31,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
                 if(hasTimeLimit){
                     res.setTimeout(timeLimit, ()=>{
                         //res.abort();
-                        SLogger.warn(funcName+" 接收反馈超时: "+timeLimit+" ms");
+                        SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
                         resolve(null);
                         return;
                     });
@@ -42,7 +42,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
                 res.on('data',(chunk)=>resdata+=chunk);
 
                 res.on('error',(e)=>{
-                    SLogger.warn(funcName+" 接收反馈错误:"+e);
+                    SLogger.warn(`${funcName} 接收反馈错误:${e}`);
                     resolve(null);
                     return;
                 });
@@ -60,7 +60,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
                         return;
                     }
                     catch(e){
-                        SLogger.warn(funcName+" 接收反馈错误:"+e+"\n原始字符串:"+resdata);
+                        SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
                         resolve(null);
                         return;
                     }
@@ -81,13 +81,13 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
         //请求超时
         if(hasTimeLimit){
             req.setTimeout(timeLimit, ()=>{
-                SLogger.warn(funcName+" 发送请求超时: "+timeLimit+" ms");
+                SLogger.warn(`${funcName} 发送请求超时: ${timeLimit} ms`);
                 req.destroy();
             });
         }
 
         req.on('error', (e)=>{
-            SLogger.warn(funcName+" 发送请求错误:"+e);
+            SLogger.warn(`${funcName} 发送请求错误:${e}`);
             resolve(null);
         });
 

package/src/UtilDecorators.ts

@@ -1,9 +1,7 @@
 import { SLogger } from "./UtilLogger";
 
 
-/**用于打印方法的调用
- * @returns {void}
- */
+/**用于打印方法的调用 */
 export function DLogger(){
     return function (target:any, propertyKey:string, descriptor:PropertyDescriptor){
         const originalMethod = descriptor.value;
@@ -15,9 +13,7 @@ export function DLogger(){
     }
 }
 
-/**用于打印异步方法的调用
- * @returns {void}
- */
+/**用于打印异步方法的调用 */
 export function DLoggerAsync(){
     return function (target:any, propertyKey:string, descriptor:PropertyDescriptor){
         const originalMethod = descriptor.value;
@@ -28,10 +24,42 @@ export function DLoggerAsync(){
         }
     }
 }
+/**try-finally包装 */
+export function Defer(deferLogic: () => void) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args: any[]) {
+            try {
+                const result = originalMethod.apply(this, args);
+                deferLogic();
+                return result;
+            } catch(e) {
+                deferLogic();
+                throw e;
+            }
+        };
+        return descriptor;
+    };
+}
+/**异步的try-finally包装 */
+export function DeferAsync(deferLogic: () => void) {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            try {
+                const result = await originalMethod.apply(this, args);
+                deferLogic();
+                return result;
+            } catch(e) {
+                deferLogic();
+                throw e;
+            }
+        };
+        return descriptor;
+    };
+}
 
-/**用于捕获方法中的错误
- * @returns {void}
- */
+/**用于捕获方法中的错误 */
 export function DCatchErrors() {
     return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
         const originalMethod = descriptor.value;
@@ -45,9 +73,7 @@ export function DCatchErrors() {
     };
 }
 
-/**用于捕获异步方法中的错误
- * @returns {void}
- */
+/**用于捕获异步方法中的错误 */
 export function DCatchErrorsAsync() {
     return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
         const originalMethod = descriptor.value;
@@ -60,3 +86,31 @@ export function DCatchErrorsAsync() {
         };
     };
 }
+
+
+function AddNumberDecorator(n: number) {
+    type NumberToNumberFunc = (num: number) => number;
+    return function(
+        this:any,
+        target: Object,
+        propertyKey: string,
+        descriptor: TypedPropertyDescriptor<NumberToNumberFunc>
+    ) {
+        const originalMethod = descriptor.value!;
+        descriptor.value = function (num: number) {
+            const result = originalMethod.apply(this, [num]);
+            return result + n;
+        };
+        return descriptor;
+    };
+}
+
+class Example {
+    @AddNumberDecorator(10)
+    myMethod(num: number): number {
+        return num;
+    }
+}
+
+//let a = new Example();
+//a.myMethod(10);//?

package/src/UtilFileTools.ts

@@ -3,6 +3,7 @@ import * as path from "path";
 import { JObject, JToken, stringifyJToken } from "./UtilInterfaces";
 import { SLogger } from "./UtilLogger";
 import * as JSON5 from 'json5';
+import { globSync } from "glob";
 
 /**文件工具 */
 export namespace UtilFT{
@@ -201,25 +202,36 @@ export async function writeJSONFile(
 /**搜索路径符合正则表达式的文件
  * @param folder - 文件夹路径
  * @param traitRegex - 正则表达式
- * @returns {Record<string, string>} 文件名与路径的映射 Record<fileName,filePath>
+ * @returns 文件名路径数组
  */
-export function fileSearch(folder: string, traitRegex: string) {
-    let outMap: Record<string, string> = {};
+export function fileSearchRegex(folder: string, traitRegex: string) {
+    let outArray: string[] = [];
     let subFiles = fs.readdirSync(folder);
     let regex = new RegExp(traitRegex);
     for (let subFile of subFiles) {
         let subFilePath = path.join(folder, subFile);
-        subFilePath = subFilePath.replace(/\\/g, "/");
         let stat = fs.lstatSync(subFilePath);
-
         //判断是否是文件夹，递归调用
         if (stat.isDirectory()) {
-            let subMap = fileSearch(path.join(subFilePath, path.sep), traitRegex);
-            for (let key in subMap) outMap[key] = subMap[key];
+            outArray.push(...fileSearchRegex(path.join(subFilePath, path.sep), traitRegex));
             continue;
         }
-        if (regex.test(subFilePath)) outMap[subFile] = subFilePath;
+        if (regex.test(subFilePath)) outArray.push(subFilePath);
     }
-    return outMap;
+    return outArray;
+}
+/**搜索符合Glob匹配的文件
+ * @param globPattern - glob匹配
+ * @param ignore - 忽略的文件
+ * @returns 文件绝对路径数组
+ */
+export function fileSearchGlob(globPattern:string|string[],ignore?:string|string[]){
+    return globSync(globPattern,{ignore,absolute:true});
+}
+/**
+ * @deprecated 请使用 fileSearchRegex 或 fileSearchGlob
+ */
+export function fileSearch(...patams:any[]){
+    throw "请使用 fileSearchRegex 或 fileSearchGlob"
 }
 }

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { JToken, ProcessingPromise, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
+import { ComposedClass, ComposedClassMult, ComposedPartClass as ComposedPartClass, FuncPropNames, JToken, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "./UtilInterfaces";
 import * as cp from "child_process";
 import { SLogger } from "./UtilLogger";
 
@@ -92,22 +92,38 @@ export function exec(command: string) {
 	});
 }
 
+/**永不完成的Promise单例 */
 const NeverResolvedPromise = new Promise(()=>{});
 /**获得一个永不完成的Promise单例 */
 export function getNeverResolvedPromise<T>():Promise<T>{
     return NeverResolvedPromise as Promise<T>;
 }
 
+/**进行中的请求 */
+type ProcessingPromise<T> = {
+    /**主体请求 */
+    result:T;
+    /**请求状态 */
+    stat:PromiseStat|Promise<PromiseStat>;
+    /**请求下标/序号 */
+    index:number;
+};
+
 /**重复尝试promise  
  * @async
  * @param {PromiseProcFn<T>} [procFn]       - 发起函数
  * @param {PromiseVerifyFn<T>} [verifyFn]   - 验证函数
- * @param {number} [repeatCount]    - 重试次数
- * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
- * @returns {Promise<T|null>}       - 结果 null 为全部失败/超时
+ * @param {number} [repeatCount]            - 重试次数
+ * @param {number} [repeatTime]             - 超时时间/秒  最小为10秒
+ * @returns {Promise<T|null>}               - 结果 null 为全部失败/超时
  */
 export async function repeatPromise<T>(procFn:PromiseProcFn<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);
     if(hasRepeatTime) repeatTime*=1000;
@@ -132,61 +148,218 @@ export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:Promise
     }
 
     //进行中的请求
-	const plist:Promise<ProcessingPromise<T>>[] = new Array(repeatCount)
-        .fill(UtilFunc.getNeverResolvedPromise());
-    for(let i=0;i<repeatCount;){
-        SLogger.info("开始第 "+(i+1)+" 次 repeatPromise");
-        //创建当前任务
-        plist[i] = procFn().then(result =>
-            ({result, stat:verifyFn!(result), index:i}));
-
-        //创建定时器
-        if(timerP==null){
-            timerP = new Promise<"Timeout">(function(resolve, rejecte){
-                resolveFn = resolve;
-                timer = setTimeout(()=>resolve("Timeout"),
-                    hasRepeatTime? repeatTime:Infinity);//无限制则无限时间
-            })
-        }
+	const plist:Promise<ProcessingPromise<T>>[] = [];
 
-        //等待完成
-        const currObj = await Promise.race([...plist, timerP]);
+    //开始处理
+    try{
+        for(let i=0;i<repeatCount;){
+            SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
+            //创建当前任务
+            if(plist.length<i+1){
+                plist.push(procFn().then(result =>
+                    ({result, stat:verifyFn!(result), index:i})));
+            }
 
-        //超时处理
-        if(currObj=="Timeout"){
-            SLogger.warn(`第 ${(i+1)} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
-            clearTimer(); i++;
-            continue;
-        }else{
+            //创建定时器
+            if(timerP==null){
+                timerP = new Promise<"Timeout">(function(resolve, rejecte){
+                    resolveFn = resolve;
+                    timer = setTimeout(()=>resolve("Timeout"),
+                        hasRepeatTime? repeatTime:Infinity);//无限制则无限时间
+                })
+            }
+
+            //等待完成
+            const currObj = await Promise.race([...plist, timerP]);
+
+            //超时处理
+            if(currObj=="Timeout"){
+                SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
+                clearTimer(); i++;
+                continue;
+            }
             const poststat = await currObj.stat;
             switch(poststat){
                 case "Completed"://完成
-                    SLogger.info("第 "+(currObj.index+1)+" 次 repeatPromise 成功");
-                    clearTimer();
+                    SLogger.info(`第 ${currObj.index+1} 次 repeatPromise 成功`);
+                    //非当前
+                    if(currObj.index!=i)
+                        SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
                     return currObj.result;
                 case "Terminated"://终止
-                    SLogger.warn("第 "+(currObj.index+1)+" 次 repeatPromise 终止 停止重试");
-                    clearTimer();
+                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 终止 停止重试`);
                     return currObj.result;
                 case "Failed"://验证失败
+                    //抛弃失败
+                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
                     //是当前
                     if(currObj.index==i){
-                        SLogger.warn("第 "+(currObj.index+1)+" 次 repeatPromise 失败 开始重试");
+                        SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败 开始重试`);
                         clearTimer(); i++;
                         continue;
                     }
                     //非当前
-                    SLogger.warn("第 "+(currObj.index+1)+" 次 repeatPromise 失败");
-                    //抛弃失败
-                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败`);
                     continue;
             }
         }
+        //全部失败或超时则返回null
+        SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
+        return null;
+    }catch(err){
+        SLogger.warn(`repeatPromise 发生错误`,err);
+        return null;
+    }finally{
+        //清理
+        clearTimer();
+        SLogger.timeEnd(timeflag);
+    }
+}
+
+
+/**柯里化函数类型 */
+type CurryFunc<T, PrevArgs extends any[] = []> = T extends (...args: infer Args) => infer Result
+    ? Args extends [infer Arg, ...infer RestArgs]
+        ? RestArgs extends []
+            ? ((...args: [...PrevArgs, Arg]) => Result )
+            : ((...args: [...PrevArgs, Arg]) => CurryFunc<(...rest:RestArgs) => Result> )
+            & (CurryFunc<(...args: RestArgs) => Result, [...PrevArgs, Arg]>)
+        : Args extends []
+            ? () => Result
+            : never
+    : never;
+
+/**柯里化转换  
+ * @param {T} fn - 将要转换的函数
+ * @returns {CurryFunc<T>} 柯里化的函数
+ */
+export function curry<T extends (...args: any[]) => any>(fn: T): CurryFunc<T> {
+    return (function curried(...args: any[]) {
+        if (args.length >= fn.length)
+            return fn(...args);
+        return (...restArgs: any[]) => curried(...args, ...restArgs);
+    }) as CurryFunc<T>;
+}
+/**
+let sumvoid = ()=>10;
+let a = curry(sumvoid);//?
+console.log(a());
+let sum = (a:number,b:string,c:number,d:boolean)=>a+b+c+d;
+let sumCu = curry(sum);//?
+let suma = sumCu(1)("ss");//?
+let sumb = sumCu(1,"1")(2);//?
+let sumc = sumCu(4);//?
+let sumz = sumCu(1,"b",3)(false);//?
+console.log(suma(2,true));
+console.log(sumb(true));
+console.log(sumc("s",3,false));
+*/
+/**可组合的函数 */
+type CompFunc<T = any, R = any> = (arg: T) => R;
+/**函数组合 从右到左执行 */
+export function compose<T>(...fs: CompFunc<T, T>[]): CompFunc<T, T>;
+export function compose<T, R>(f1: CompFunc<T, R>): CompFunc<T, R>;
+export function compose<T, R, R1>(f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R1>;
+export function compose<T, R, R1, R2>(f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R2>;
+export function compose<T, R, R1, R2, R3>(f4: CompFunc<R2, R3>, f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R3>;
+export function compose<T, R, R1, R2, R3, R4>(f5: CompFunc<R3, R4>,f4: CompFunc<R2, R3>, f3: CompFunc<R1, R2>, f2: CompFunc<R, R1>, f1: CompFunc<T, R>): CompFunc<T, R4>;
+/**函数组合  
+ * 从右到左执行  
+ * @param {Function[]} funcs - 待组合的函数
+ * @returns {(arg: any)=>any} 组合完成的函数
+ */
+export function compose(...funcs: Function[]) {
+    return (arg: any) => funcs.reduceRight((value, func) => func(value), arg);
+}
+/**函数管道 从左到右执行  */
+export function pipeline<T>(...fs: CompFunc<T, T>[]): CompFunc<T, T>;
+export function pipeline<T, R>(f1: CompFunc<T, R>): CompFunc<T, R>;
+export function pipeline<T, R, R1>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>): CompFunc<T, R1>;
+export function pipeline<T, R, R1, R2>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>): CompFunc<T, R2>;
+export function pipeline<T, R, R1, R2, R3>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>, f4: CompFunc<R2, R3>): CompFunc<T, R3>;
+export function pipeline<T, R, R1, R2, R3, R4>(f1: CompFunc<T, R>, f2: CompFunc<R, R1>, f3: CompFunc<R1, R2>, f4: CompFunc<R2, R3>, f5: CompFunc<R3, R4>): CompFunc<T, R4>;
+/**函数管道  
+ * 从左到右执行  
+ * @param {((arg: T) => T)} funcs - 待组合的函数
+ * @returns {((arg: T) => T)} 组合完成的函数
+ */
+export function pipeline<T>(...funcs: ((arg: T) => T)[]): (arg: T) => T {
+    return (arg: T): T => {
+        return funcs.reduce((value, func) => func(value), arg);
+    };
+}
+
+/**部分类组合  
+ * 将mixin的部分字段混入base  
+ * @param base   - 基础类
+ * @param mixin  - 目标类
+ * @param fields - 需要混入的字段
+ * @returns - 混合完成的类
+ */
+export function composePartClass<Base extends object,Mixin extends object>
+    (base:Base,mixin:Mixin,...fields:(keyof Mixin)[]):ComposedPartClass<Base,Mixin,keyof Mixin>{
+    const compObj = base as any;
+    for(const fd of fields){
+        Object.defineProperty(compObj, fd, {
+            get: ()=>mixin[fd],
+            set: (value)=>{mixin[fd] = value},
+            enumerable:true ,
+            //writable: true  ,
+            configurable: true
+        });
+        //(compObj as any)[fd] = (mixin[fd] as any).bind(mixin);
+    }
+    return compObj;
+}
+/**类组合  
+ * 将mixinList每个成员的字段混入base  
+ * @param base      - 基础类
+ * @param mixinList - 目标类
+ * @returns - 混合完成的类
+ */
+export function composeClass<Base extends object,MixinList extends object[]>
+    (base:Base,...mixinList:MixinList):ComposedClassMult<Base,MixinList>{
+    let obj = base as any;
+    for(let mixin of mixinList as any){
+        let propks = Object.getOwnPropertyNames(mixin.constructor.prototype)
+        for(const key of propks){
+            if(key != "constructor"){
+                Object.defineProperty(obj, key, {
+                    get: ()=>mixin[key],
+                    set: (value)=>{mixin[key] = value},
+                    enumerable:true,
+                    //writable: true,
+                    configurable: true
+                });
+                //obj[key] = (mixin as any)[key];
+            }
+        }
+        for(const key in mixin){
+            Object.defineProperty(obj, key, {
+                get: ()=>mixin[key],
+                set: (value)=>{mixin[key] = value},
+                enumerable:true ,
+                //writable: true  ,
+                configurable: true
+            });
+            //obj[key] = (mixin as any)[key];
+        }
     }
-    clearTimer();
-    //全部失败或超时则返回null
-    return null;
+    return obj;
 }
 
+/**对对象的每个属性应用映射函数，并返回一个新的对象。
+ * @template T      - 对象的类型
+ * @param obj       - 要处理的对象
+ * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
+ * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
+ */
+export function mapObject<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);
+        return result;
+    }, {} as T);
 }
 
+}

package/src/UtilInterfaces.ts

@@ -72,16 +72,6 @@ export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string
     TMP extends JArray = ExclusiveRecursive<B,T,K>> = TMP[number];
 
 
-/**进行中的请求 */
-export type ProcessingPromise<T> = {
-    /**主体请求 */
-    result:T;
-    /**请求状态 */
-    stat:PromiseStat|Promise<PromiseStat>;
-    /**请求下标/序号 */
-    index:number;
-};
-
 /**请求完成状态 成功/失败/终止  
  * 成功/终止 将直接返回  
  * 失败 将重试  
@@ -90,4 +80,59 @@ export type PromiseStat = "Completed"|"Failed"|"Terminated";
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj:T)=>Promise<PromiseStat>|PromiseStat;
 /**发起promise的函数 */
-export type PromiseProcFn<T> = ()=>Promise<T>;
+export type PromiseProcFn<T> = ()=>Promise<T>;
+
+/**类型中任意函数的字符串名称 */
+export type FuncPropNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+/**部分组合的类 
+ * @template {Base}     - 基类
+ * @template {Mixin}    - 待混入的类
+ * @template {PropKeys} - 需要混入的成员key
+ */
+export type ComposedPartClass<Base extends object, Mixin extends object, PropKeys extends keyof Mixin> = 
+    Base & Pick<Mixin, PropKeys>;
+
+/**组合的类 嵌套变体 */
+export type ComposedPartClassMult<Base extends object, 
+    Mixin1 extends object = {}, PropKeys1 extends keyof Mixin1 = keyof Mixin1,
+    Mixin2 extends object = {}, PropKeys2 extends keyof Mixin2 = keyof Mixin2,
+    Mixin3 extends object = {}, PropKeys3 extends keyof Mixin3 = keyof Mixin3,
+    Mixin4 extends object = {}, PropKeys4 extends keyof Mixin4 = keyof Mixin4,
+    Mixin5 extends object = {}, PropKeys5 extends keyof Mixin5 = keyof Mixin5,
+    Mixin6 extends object = {}, PropKeys6 extends keyof Mixin6 = keyof Mixin6> = 
+    ComposedPartClass<ComposedPartClass<ComposedPartClass<
+    ComposedPartClass<ComposedPartClass<ComposedPartClass<
+    Base,
+    Mixin1,PropKeys1>,Mixin2,PropKeys2>,Mixin3,PropKeys3>,
+    Mixin4,PropKeys4>,Mixin5,PropKeys5>,Mixin6,PropKeys6>
+
+/**递归多组合 仅单key有效 */
+type ComposedClassOnceKey<Base extends object,Data extends [object,string][]> = 
+    Data extends [[infer Mixin extends object, infer FuncKeys], ...infer Rest]
+        ? FuncKeys extends FuncPropNames<Mixin>
+            ? Rest extends [any, any][]
+                ? ComposedClassOnceKey<ComposedPartClass<Base, Mixin, FuncKeys>,Rest>
+                : Base
+            : Base
+        : Base;
+
+/**组合的类  
+ * @template {Base}     - 基类
+ * @template {Mixin}    - 待混入的类
+ */
+export type ComposedClass<Base extends object,Mixin extends object> = Base&Mixin;
+/**组合的类 多组合变体  
+ * @template {Base}     - 基类
+ * @template {MixinList}- 待混入的类型数组
+ */
+export type ComposedClassMult<Base extends object,MixinList extends object[]> = 
+    MixinList extends [infer Mixin, ...infer Rest]
+        ? Mixin extends object
+            ? Rest extends object[]
+                ? ComposedClassMult<ComposedClass<Base,Mixin>,Rest>
+                : Base
+            : Base
+        : Base;