@zwa73/utils 1.0.47 → 1.0.49

package/dist/UtilClass.d.ts

@@ -500,4 +500,40 @@ export declare class SHashMap<K, V> {
         };
     };
 }
+/**函数组合器 */
+export declare class Composer<Result, PreArg = Result> {
+    /**组合函数列表 */
+    private funcs;
+    private constructor();
+    /**添加单个参数与返回值不同的函数 */
+    static push<Result, Arg>(func: (arg: Arg) => Result): Composer<Result, Arg>;
+    /**添加多个参数与返回值相同的函数 */
+    static push<Result>(func: ((arg: Result) => Result), ...funcs: ((arg: Result) => Result)[]): Composer<Result>;
+    /**添加单个参数与返回值不同的函数 */
+    push<T>(func: (arg: T) => PreArg): Composer<Result, T>;
+    /**添加多个参数与返回值相同的函数 */
+    push(func: ((arg: Result) => Result), ...funcs: ((arg: PreArg) => PreArg)[]): Composer<Result, PreArg>;
+    /**组合函数 */
+    compose(): (arg: PreArg) => Result;
+    /**直接调用 */
+    invoke(arg: PreArg): Result;
+}
+/**函数管道器 */
+export declare class Piper<Arg, Result = Arg> {
+    /**管道函数列表 */
+    private funcs;
+    private constructor();
+    /**添加单个参数与返回值不同的函数 */
+    static pipe<Arg, Result>(func: (arg: Arg) => Result): Piper<Arg, Result>;
+    /**添加多个参数与返回值相同的函数 */
+    static pipe<Arg>(func: ((arg: Arg) => Arg), ...funcs: ((arg: Arg) => Arg)[]): Piper<Arg>;
+    /**添加单个参数与返回值不同的函数 */
+    pipe<T>(func: (arg: Result) => T): Piper<Arg, T>;
+    /**添加多个参数与返回值相同的函数 */
+    pipe(func: ((arg: Result) => Result), ...funcs: ((arg: Result) => Result)[]): Piper<Arg, Result>;
+    /**管道函数 */
+    pipeline(): (arg: Arg) => Result;
+    /**直接调用 */
+    invoke(arg: Arg): Result;
+}
 export {};

package/dist/UtilClass.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHashMap = exports.SEntry = exports.SIterator = exports.SStream = exports.SList = void 0;
+exports.Piper = exports.Composer = exports.SHashMap = exports.SEntry = exports.SIterator = exports.SStream = exports.SList = void 0;
 class SList {
     _arr;
     constructor(obj) {
@@ -840,3 +840,55 @@ class SKVC {
     stringMap = new SHashMap();
     constructor() { }
 }
+/**函数组合器 */
+class Composer {
+    /**组合函数列表 */
+    funcs = [];
+    constructor() { }
+    ;
+    static push(...funcs) {
+        const newComposer = new Composer();
+        newComposer.funcs = [...funcs];
+        return newComposer;
+    }
+    push(...funcs) {
+        const newComposer = new Composer();
+        newComposer.funcs = [...this.funcs, ...funcs];
+        return newComposer;
+    }
+    /**组合函数 */
+    compose() {
+        return (arg) => this.funcs.reduceRight((value, func) => func(value), arg);
+    }
+    /**直接调用 */
+    invoke(arg) {
+        return this.funcs.reduceRight((value, func) => func(value), arg);
+    }
+}
+exports.Composer = Composer;
+/**函数管道器 */
+class Piper {
+    /**管道函数列表 */
+    funcs = [];
+    constructor() { }
+    ;
+    static pipe(...funcs) {
+        const newPiper = new Piper();
+        newPiper.funcs = [...funcs];
+        return newPiper;
+    }
+    pipe(...funcs) {
+        const newPiper = new Piper();
+        newPiper.funcs = [...this.funcs, ...funcs];
+        return newPiper;
+    }
+    /**管道函数 */
+    pipeline() {
+        return (arg) => this.funcs.reduce((value, func) => func(value), arg);
+    }
+    /**直接调用 */
+    invoke(arg) {
+        return this.funcs.reduce((value, func) => func(value), arg);
+    }
+}
+exports.Piper = Piper;

package/dist/UtilCom.js

@@ -22,7 +22,7 @@ var UtilCom;
         if (hasTimeLimit)
             timeLimit *= 1000;
         const jsonStr = (0, UtilInterfaces_1.stringifyJToken)(json);
-        const funcName = "s" + posttype + "Psot";
+        const funcName = `s${posttype}Psot`;
         return new Promise((resolve, rejecte) => {
             const resFunc = (res) => {
                 try {
@@ -30,7 +30,7 @@ var UtilCom;
                     if (hasTimeLimit) {
                         res.setTimeout(timeLimit, () => {
                             //res.abort();
-                            UtilLogger_1.SLogger.warn(funcName + " 接收反馈超时: " + timeLimit + " ms");
+                            UtilLogger_1.SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
                             resolve(null);
                             return;
                         });
@@ -39,7 +39,7 @@ var UtilCom;
                     res.setEncoding('utf8');
                     res.on('data', (chunk) => resdata += chunk);
                     res.on('error', (e) => {
-                        UtilLogger_1.SLogger.warn(funcName + " 接收反馈错误:" + e);
+                        UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误:${e}`);
                         resolve(null);
                         return;
                     });
@@ -56,7 +56,7 @@ var UtilCom;
                             return;
                         }
                         catch (e) {
-                            UtilLogger_1.SLogger.warn(funcName + " 接收反馈错误:" + e + "\n原始字符串:" + resdata);
+                            UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
                             resolve(null);
                             return;
                         }
@@ -77,12 +77,12 @@ var UtilCom;
             //请求超时
             if (hasTimeLimit) {
                 req.setTimeout(timeLimit, () => {
-                    UtilLogger_1.SLogger.warn(funcName + " 发送请求超时: " + timeLimit + " ms");
+                    UtilLogger_1.SLogger.warn(`${funcName} 发送请求超时: ${timeLimit} ms`);
                     req.destroy();
                 });
             }
             req.on('error', (e) => {
-                UtilLogger_1.SLogger.warn(funcName + " 发送请求错误:" + e);
+                UtilLogger_1.SLogger.warn(`${funcName} 发送请求错误:${e}`);
                 resolve(null);
             });
             req.write(jsonStr);

package/dist/UtilDecorators.d.ts

@@ -1,16 +1,12 @@
-/**用于打印方法的调用
- * @returns {void}
- */
+/**用于打印方法的调用 */
 export declare function DLogger(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-/**用于打印异步方法的调用
- * @returns {void}
- */
+/**用于打印异步方法的调用 */
 export declare function DLoggerAsync(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-/**用于捕获方法中的错误
- * @returns {void}
- */
+/**try-finally包装 */
+export declare function Defer(deferLogic: () => void): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**异步的try-finally包装 */
+export declare function DeferAsync(deferLogic: () => void): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**用于捕获方法中的错误 */
 export declare function DCatchErrors(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-/**用于捕获异步方法中的错误
- * @returns {void}
- */
+/**用于捕获异步方法中的错误 */
 export declare function DCatchErrorsAsync(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/UtilDecorators.js

@@ -1,10 +1,17 @@
 "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.DCatchErrorsAsync = exports.DCatchErrors = exports.DLoggerAsync = exports.DLogger = void 0;
+exports.DCatchErrorsAsync = exports.DCatchErrors = exports.DeferAsync = exports.Defer = exports.DLoggerAsync = exports.DLogger = void 0;
 const UtilLogger_1 = require("./UtilLogger");
-/**用于打印方法的调用
- * @returns {void}
- */
+/**用于打印方法的调用 */
 function DLogger() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
@@ -16,9 +23,7 @@ function DLogger() {
     };
 }
 exports.DLogger = DLogger;
-/**用于打印异步方法的调用
- * @returns {void}
- */
+/**用于打印异步方法的调用 */
 function DLoggerAsync() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
@@ -30,9 +35,45 @@ function DLoggerAsync() {
     };
 }
 exports.DLoggerAsync = DLoggerAsync;
-/**用于捕获方法中的错误
- * @returns {void}
- */
+/**try-finally包装 */
+function Defer(deferLogic) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            try {
+                const result = originalMethod.apply(this, args);
+                deferLogic();
+                return result;
+            }
+            catch (e) {
+                deferLogic();
+                throw e;
+            }
+        };
+        return descriptor;
+    };
+}
+exports.Defer = Defer;
+/**异步的try-finally包装 */
+function DeferAsync(deferLogic) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            try {
+                const result = await originalMethod.apply(this, args);
+                deferLogic();
+                return result;
+            }
+            catch (e) {
+                deferLogic();
+                throw e;
+            }
+        };
+        return descriptor;
+    };
+}
+exports.DeferAsync = DeferAsync;
+/**用于捕获方法中的错误 */
 function DCatchErrors() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
@@ -47,9 +88,7 @@ function DCatchErrors() {
     };
 }
 exports.DCatchErrors = DCatchErrors;
-/**用于捕获异步方法中的错误
- * @returns {void}
- */
+/**用于捕获异步方法中的错误 */
 function DCatchErrorsAsync() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
@@ -64,3 +103,26 @@ function DCatchErrorsAsync() {
     };
 }
 exports.DCatchErrorsAsync = DCatchErrorsAsync;
+function AddNumberDecorator(n) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (num) {
+            const result = originalMethod.apply(this, [num]);
+            return result + n;
+        };
+        return descriptor;
+    };
+}
+class Example {
+    myMethod(num) {
+        return num;
+    }
+}
+__decorate([
+    AddNumberDecorator(10),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Number)
+], Example.prototype, "myMethod", null);
+//let a = new Example();
+//a.myMethod(10);//?

package/dist/UtilFileTools.d.ts

@@ -76,7 +76,17 @@ export declare namespace UtilFT {
     /**搜索路径符合正则表达式的文件
      * @param folder - 文件夹路径
      * @param traitRegex - 正则表达式
-     * @returns {Record<string, string>} 文件名与路径的映射 Record<fileName,filePath>
+     * @returns 文件名路径数组
      */
-    function fileSearch(folder: string, traitRegex: string): Record<string, string>;
+    function fileSearchRegex(folder: string, traitRegex: string): string[];
+    /**搜索符合Glob匹配的文件
+     * @param globPattern - glob匹配
+     * @param ignore - 忽略的文件
+     * @returns 文件绝对路径数组
+     */
+    function fileSearchGlob(globPattern: string | string[], ignore?: string | string[]): string[];
+    /**
+     * @deprecated 请使用 fileSearchRegex 或 fileSearchGlob
+     */
+    function fileSearch(...patams: any[]): void;
 }

package/dist/UtilFileTools.js

@@ -6,6 +6,7 @@ const path = require("path");
 const UtilInterfaces_1 = require("./UtilInterfaces");
 const UtilLogger_1 = require("./UtilLogger");
 const JSON5 = require("json5");
+const glob_1 = require("glob");
 /**文件工具 */
 var UtilFT;
 (function (UtilFT) {
@@ -168,27 +169,40 @@ var UtilFT;
     /**搜索路径符合正则表达式的文件
      * @param folder - 文件夹路径
      * @param traitRegex - 正则表达式
-     * @returns {Record<string, string>} 文件名与路径的映射 Record<fileName,filePath>
+     * @returns 文件名路径数组
      */
-    function fileSearch(folder, traitRegex) {
-        let outMap = {};
+    function fileSearchRegex(folder, traitRegex) {
+        let outArray = [];
         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;
+                outArray.push(subFilePath);
         }
-        return outMap;
+        return outArray;
+    }
+    UtilFT.fileSearchRegex = fileSearchRegex;
+    /**搜索符合Glob匹配的文件
+     * @param globPattern - glob匹配
+     * @param ignore - 忽略的文件
+     * @returns 文件绝对路径数组
+     */
+    function fileSearchGlob(globPattern, ignore) {
+        return (0, glob_1.globSync)(globPattern, { ignore, absolute: true });
+    }
+    UtilFT.fileSearchGlob = fileSearchGlob;
+    /**
+     * @deprecated 请使用 fileSearchRegex 或 fileSearchGlob
+     */
+    function fileSearch(...patams) {
+        throw "请使用 fileSearchRegex 或 fileSearchGlob";
     }
     UtilFT.fileSearch = fileSearch;
 })(UtilFT = exports.UtilFT || (exports.UtilFT = {}));

package/dist/UtilFunctions.d.ts

@@ -1,11 +1,11 @@
-import { JToken, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
+import { ComposedClassMult, ComposedPartClass as ComposedPartClass, JToken, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
 /**常用函数 */
 export declare namespace UtilFunc {
     /**获取当前时间戳
      * number ()
      * @returns {number} 时间戳
      */
-    function getTime(): number;
+    export function getTime(): number;
     /**初始化对象的字段
      * void (Object,string,any)
      * @param {Record<string,T>} obj   - 所要初始化的对象
@@ -13,51 +13,111 @@ export declare namespace UtilFunc {
      * @param {T} defaultVal 		   - 默认值
      * @returns {T} - 最终值
      */
-    function initField<T>(obj: Record<string, T>, field: string, defaultVal: T): T;
+    export function initField<T>(obj: Record<string, T>, field: string, defaultVal: T): T;
     /**生成一串uuid
      * string ()
      * @returns {string} uuid
      */
-    function genUUID(): string;
+    export function genUUID(): string;
     /**计算Hash
      * string ()
      * @param {string} str - 待计算的字符串
      * @returns {string} hash
      */
-    function calcHash(str: string): string;
+    export function calcHash(str: string): string;
     /**深克隆 序列化并反序列化
      * @template {T} T - JToken类型的泛型
      * @param {T} obj - 克隆目标
      * @returns {T}   克隆结果
      */
-    function deepClone<T extends JToken>(obj: T): T;
+    export function deepClone<T extends JToken>(obj: T): T;
     /**是否为安全的数字
      * @param {number} num - 所要检测的数字
      * @returns {boolean} 是否安全
      */
-    function isSafeNumber(num: number): boolean;
+    export function isSafeNumber(num: number): boolean;
     /**等待 timeMs 毫秒
      * @async
      * @param {number} timeMs - 等待的毫秒数
      * @returns {Promise<boolean>}
      */
-    function sleep(timeMs: number): Promise<boolean>;
+    export function sleep(timeMs: number): Promise<boolean>;
     /**封装的 cp.exec 执行一段指令 指令完成后返回 Promise
      * @param {string} command 指令文本
      */
-    function exec(command: string): Promise<{
+    export function exec(command: string): Promise<{
         stdout: string;
         stderr: string;
     }>;
     /**获得一个永不完成的Promise单例 */
-    function getNeverResolvedPromise<T>(): Promise<T>;
+    export function getNeverResolvedPromise<T>(): Promise<T>;
     /**重复尝试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 为全部失败/超时
      */
-    function repeatPromise<T>(procFn: PromiseProcFn<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
+    export function repeatPromise<T>(procFn: PromiseProcFn<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
+    /**柯里化函数类型 */
+    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>;
+    /**
+    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>;
+    /**函数管道 从左到右执行  */
+    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>;
+    /**部分类组合
+     * 将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>;
+    /**类组合
+     * 将mixinList每个成员的字段混入base
+     * @param base      - 基础类
+     * @param mixinList - 目标类
+     * @returns - 混合完成的类
+     */
+    export function composeClass<Base extends object, MixinList extends object[]>(base: Base, ...mixinList: MixinList): ComposedClassMult<Base, MixinList>;
+    /**对对象的每个属性应用映射函数，并返回一个新的对象。
+     * @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;
+    export {};
 }

package/dist/UtilFunctions.js

@@ -93,6 +93,7 @@ var UtilFunc;
         });
     }
     UtilFunc.exec = exec;
+    /**永不完成的Promise单例 */
     const NeverResolvedPromise = new Promise(() => { });
     /**获得一个永不完成的Promise单例 */
     function getNeverResolvedPromise() {
@@ -103,9 +104,9 @@ var UtilFunc;
      * @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 为全部失败/超时
      */
     async function repeatPromise(procFn, verifyFn, repeatCount = 3, repeatTime = 180) {
         //计时
@@ -199,4 +200,107 @@ var UtilFunc;
         }
     }
     UtilFunc.repeatPromise = repeatPromise;
+    /**柯里化转换
+     * @param {T} fn - 将要转换的函数
+     * @returns {CurryFunc<T>} 柯里化的函数
+     */
+    function curry(fn) {
+        return (function curried(...args) {
+            if (args.length >= fn.length)
+                return fn(...args);
+            return (...restArgs) => curried(...args, ...restArgs);
+        });
+    }
+    UtilFunc.curry = curry;
+    /**函数组合
+     * 从右到左执行
+     * @param {Function[]} funcs - 待组合的函数
+     * @returns {(arg: any)=>any} 组合完成的函数
+     */
+    function compose(...funcs) {
+        return (arg) => funcs.reduceRight((value, func) => func(value), arg);
+    }
+    UtilFunc.compose = compose;
+    /**函数管道
+     * 从左到右执行
+     * @param {((arg: T) => T)} funcs - 待组合的函数
+     * @returns {((arg: T) => T)} 组合完成的函数
+     */
+    function pipeline(...funcs) {
+        return (arg) => {
+            return funcs.reduce((value, func) => func(value), arg);
+        };
+    }
+    UtilFunc.pipeline = pipeline;
+    /**部分类组合
+     * 将mixin的部分字段混入base
+     * @param base   - 基础类
+     * @param mixin  - 目标类
+     * @param fields - 需要混入的字段
+     * @returns - 混合完成的类
+     */
+    function composePartClass(base, mixin, ...fields) {
+        const compObj = base;
+        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;
+    }
+    UtilFunc.composePartClass = composePartClass;
+    /**类组合
+     * 将mixinList每个成员的字段混入base
+     * @param base      - 基础类
+     * @param mixinList - 目标类
+     * @returns - 混合完成的类
+     */
+    function composeClass(base, ...mixinList) {
+        let obj = base;
+        for (let mixin of mixinList) {
+            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];
+            }
+        }
+        return obj;
+    }
+    UtilFunc.composeClass = composeClass;
+    /**对对象的每个属性应用映射函数，并返回一个新的对象。
+     * @template T      - 对象的类型
+     * @param obj       - 要处理的对象
+     * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
+     * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
+     */
+    function mapObject(obj, mapper) {
+        return Object.entries(obj).reduce((result, [key, value]) => {
+            result[key] = mapper(key, value);
+            return result;
+        }, {});
+    }
+    UtilFunc.mapObject = mapObject;
 })(UtilFunc = exports.UtilFunc || (exports.UtilFunc = {}));

package/dist/UtilInterfaces.d.ts

@@ -63,4 +63,26 @@ export type PromiseStat = "Completed" | "Failed" | "Terminated";
 export type PromiseVerifyFn<T> = (obj: T) => Promise<PromiseStat> | PromiseStat;
 /**发起promise的函数 */
 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>;
+/**组合的类
+ * @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;
 export {};