@zwa73/utils 1.0.57 → 1.0.61

package/dist/UtilCodecs.d.ts

@@ -1,43 +1,43 @@
 /**编码/解码器 */
 export declare namespace UtilCodec {
     /**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
-     * @param {string} str - 要转换的字符串
-     * @returns {string} 转换后的字符串
+     * @param str - 要转换的字符串
+     * @returns 转换后的字符串
      */
     function decodeHtmlEntities(str: string): string;
     /**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
-     * @param {string} str - 要转换的字符串
-     * @returns {string} 转换后的字符串
+     * @param str - 要转换的字符串
+     * @returns 转换后的字符串
      */
     function encodeHtmlEntities(str: string): string;
     /**token长度计算器 Turbo模型
-     * @param {string} str = 所要计算的消息
-     * @returns {number} 整数长度结果
+     * @param str = 所要计算的消息
+     * @returns 整数长度结果
      */
     function tokenNumTurbo(str: string): number;
     /**token长度计算器 Davinci模型
-     * @param {string} str = 所要计算的消息
-     * @returns {number} 整数长度结果
+     * @param str = 所要计算的消息
+     * @returns 整数长度结果
      */
     function tokenNumDavinci(str: string): number;
     /**token编码 Turbo模型
-     * @param {string} str = 所要计算的消息
-     * @returns {Array<number>} Token数组
+     * @param str = 所要计算的消息
+     * @returns Token数组
      */
     function encodeTokenTurbo(str: string): Uint32Array;
     /**token编码 Davinci模型
-     * @param {string} str = 所要计算的消息
-     * @returns {Array<number>} Token数组
+     * @param str = 所要计算的消息
+     * @returns Token数组
      */
     function encodeTokenDavinci(str: string): Uint32Array;
     /**token解码 Turbo模型
-     * @param {Array<number>} arr = Token数组
-     * @returns {string} 消息字符串
+     * @param arr = Token数组
+     * @returns 消息字符串
      */
     function decodeTokenTurbo(arr: Uint32Array): string;
     /**token解码 Davinci模型
-     * @param {Array<number>} arr = Token数组
-     * @returns {string} 消息字符串
+     * @param arr = Token数组
+     * @returns 消息字符串
      */
     function decodeTokenDavinci(arr: Uint32Array): string;
 }

package/dist/UtilCodecs.js

@@ -20,8 +20,8 @@ var UtilCodec;
         "]": "]"
     };
     /**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
-     * @param {string} str - 要转换的字符串
-     * @returns {string} 转换后的字符串
+     * @param str - 要转换的字符串
+     * @returns 转换后的字符串
      */
     function decodeHtmlEntities(str) {
         //for(let code in htmlEntities){
@@ -33,8 +33,8 @@ var UtilCodec;
     }
     UtilCodec.decodeHtmlEntities = decodeHtmlEntities;
     /**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
-     * @param {string} str - 要转换的字符串
-     * @returns {string} 转换后的字符串
+     * @param str - 要转换的字符串
+     * @returns 转换后的字符串
      */
     function encodeHtmlEntities(str) {
         //for(let code in htmlEntities){
@@ -57,8 +57,8 @@ var UtilCodec;
         encoderDavinci = (0, tiktoken_1.get_encoding)("p50k_base");
     }
     /**token长度计算器 Turbo模型
-     * @param {string} str = 所要计算的消息
-     * @returns {number} 整数长度结果
+     * @param str = 所要计算的消息
+     * @returns 整数长度结果
      */
     function tokenNumTurbo(str) {
         initTikTokenEncoder();
@@ -67,8 +67,8 @@ var UtilCodec;
     }
     UtilCodec.tokenNumTurbo = tokenNumTurbo;
     /**token长度计算器 Davinci模型
-     * @param {string} str = 所要计算的消息
-     * @returns {number} 整数长度结果
+     * @param str = 所要计算的消息
+     * @returns 整数长度结果
      */
     function tokenNumDavinci(str) {
         initTikTokenEncoder();
@@ -76,8 +76,8 @@ var UtilCodec;
     }
     UtilCodec.tokenNumDavinci = tokenNumDavinci;
     /**token编码 Turbo模型
-     * @param {string} str = 所要计算的消息
-     * @returns {Array<number>} Token数组
+     * @param str = 所要计算的消息
+     * @returns Token数组
      */
     function encodeTokenTurbo(str) {
         initTikTokenEncoder();
@@ -85,8 +85,8 @@ var UtilCodec;
     }
     UtilCodec.encodeTokenTurbo = encodeTokenTurbo;
     /**token编码 Davinci模型
-     * @param {string} str = 所要计算的消息
-     * @returns {Array<number>} Token数组
+     * @param str = 所要计算的消息
+     * @returns Token数组
      */
     function encodeTokenDavinci(str) {
         initTikTokenEncoder();
@@ -94,8 +94,8 @@ var UtilCodec;
     }
     UtilCodec.encodeTokenDavinci = encodeTokenDavinci;
     /**token解码 Turbo模型
-     * @param {Array<number>} arr = Token数组
-     * @returns {string} 消息字符串
+     * @param arr = Token数组
+     * @returns 消息字符串
      */
     function decodeTokenTurbo(arr) {
         initTikTokenEncoder();
@@ -103,8 +103,8 @@ var UtilCodec;
     }
     UtilCodec.decodeTokenTurbo = decodeTokenTurbo;
     /**token解码 Davinci模型
-     * @param {Array<number>} arr = Token数组
-     * @returns {string} 消息字符串
+     * @param arr = Token数组
+     * @returns 消息字符串
      */
     function decodeTokenDavinci(arr) {
         initTikTokenEncoder();

package/dist/UtilCom.d.ts

@@ -2,45 +2,42 @@ import { JObject, PromiseVerifyFn } from "./UtilInterfaces";
 /**网络工具 */
 export declare namespace UtilCom {
     /**发送一个 https POST请求并接受数据
-     * Object ()
      * @async
-     * @param {JObject} json 	   - 数据对象
-     * @param {Object} options     - 参数对象
-     * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
-     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
+     * @param json 	    - 数据对象
+     * @param options   - 参数对象
+     * @param timeLimit - 超时时间/秒  最小为10秒
+     * @returns 结果 null 为未能成功接收
      */
     function shttpsPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
     /**发送一个 http POST请求并接受数据
-     * Object ()
      * @async
-     * @param {JObject} json 	   - 数据对象
-     * @param {Object} options     - 参数对象
-     * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
-     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
+     * @param json 	    - 数据对象
+     * @param options   - 参数对象
+     * @param timeLimit - 超时时间/秒  最小为10秒
+     * @returns 结果 null 为未能成功接收
      */
     function shttpPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
     /**重复一个 https POST请求并接受数据
-     * Object ()
      * @async
-     * @param {JObject} json 	        - 数据对象
-     * @param {Object} options          - 参数对象
-     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
-     * @param {number} [repeatCount]    - 重试次数
-     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
-     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     * @param json 	      - 数据对象
+     * @param options     - 参数对象
+     * @param timeLimit   - 超时时间/秒  最小为10秒
+     * @param repeatCount - 重试次数
+     * @param repeatTime  - 超时时间/秒  最小为10秒
+     * @param verifyFn    - 判断有效性函数
+     * @returns 结果 null 为未能成功接收
      */
     function shttpsRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, verifyFn?: PromiseVerifyFn<JObject | null>): Promise<JObject | null>;
     /**重复一个 http POST请求并接受数据
      * Object ()
      * @async
-     * @param {JObject} json 	        - 数据对象
-     * @param {Object} options          - 参数对象
-     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
-     * @param {number} [repeatCount]    - 重试次数
-     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
-     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     * @param json 	      - 数据对象
+     * @param options     - 参数对象
+     * @param timeLimit   - 超时时间/秒  最小为10秒
+     * @param repeatCount - 重试次数
+     * @param repeatTime  - 超时时间/秒  最小为10秒
+     * @param verifyFn    - 判断有效性函数
+     * @returns 结果 null 为未能成功接收
      */
     function shttpRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, verifyFn?: PromiseVerifyFn<JObject | null>): Promise<JObject | null>;
 }

package/dist/UtilCom.js

@@ -10,11 +10,11 @@ const UtilFunctions_1 = require("./UtilFunctions");
 var UtilCom;
 (function (UtilCom) {
     /**通用post处理
-     * @param {"http"|"https"} posttype - post类型
-     * @param {JObject} json 	        - 数据对象
-     * @param {Object} options          - 参数对象
-     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
-     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
+     * @param posttype  - post类型
+     * @param json 	    - 数据对象
+     * @param options   - 参数对象
+     * @param timeLimit - 超时时间/秒  最小为10秒
+     * @returns 结果 null 为未能成功接收
      */
     function sPost(posttype, json, options, timeLimit = -1) {
         //转换为毫秒
@@ -90,24 +90,22 @@ var UtilCom;
         });
     }
     /**发送一个 https POST请求并接受数据
-     * Object ()
      * @async
-     * @param {JObject} json 	   - 数据对象
-     * @param {Object} options     - 参数对象
-     * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
-     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
+     * @param json 	    - 数据对象
+     * @param options   - 参数对象
+     * @param timeLimit - 超时时间/秒  最小为10秒
+     * @returns 结果 null 为未能成功接收
      */
     function shttpsPost(json, options, timeLimit = -1) {
         return sPost("https", json, options, timeLimit);
     }
     UtilCom.shttpsPost = shttpsPost;
     /**发送一个 http POST请求并接受数据
-     * Object ()
      * @async
-     * @param {JObject} json 	   - 数据对象
-     * @param {Object} options     - 参数对象
-     * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
-     * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
+     * @param json 	    - 数据对象
+     * @param options   - 参数对象
+     * @param timeLimit - 超时时间/秒  最小为10秒
+     * @returns 结果 null 为未能成功接收
      */
     function shttpPost(json, options, timeLimit = -1) {
         return sPost("http", json, options, timeLimit);
@@ -115,29 +113,28 @@ var UtilCom;
     UtilCom.shttpPost = shttpPost;
     /**通用重复post处理
      * @async
-     * @param {"http"|"https"} posttype - post类型
-     * @param {JObject} json 	        - 数据对象
-     * @param {Object} options          - 参数对象
-     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
-     * @param {number} [repeatCount]    - 重试次数
-     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
-     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     * @param posttype    - post类型
+     * @param json 	      - 数据对象
+     * @param options     - 参数对象
+     * @param timeLimit   - 超时时间/秒  最小为10秒
+     * @param repeatCount - 重试次数
+     * @param repeatTime  - 超时时间/秒  最小为10秒
+     * @param verifyFn    - 判断有效性函数
+     * @returns 结果 null 为未能成功接收
      */
     async function sRepeatPost(posttype, json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, verifyFn) {
         const procFn = () => sPost(posttype, json, options, timeLimit);
         return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, repeatCount, repeatTime);
     }
     /**重复一个 https POST请求并接受数据
-     * Object ()
      * @async
-     * @param {JObject} json 	        - 数据对象
-     * @param {Object} options          - 参数对象
-     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
-     * @param {number} [repeatCount]    - 重试次数
-     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
-     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     * @param json 	      - 数据对象
+     * @param options     - 参数对象
+     * @param timeLimit   - 超时时间/秒  最小为10秒
+     * @param repeatCount - 重试次数
+     * @param repeatTime  - 超时时间/秒  最小为10秒
+     * @param verifyFn    - 判断有效性函数
+     * @returns 结果 null 为未能成功接收
      */
     function shttpsRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, verifyFn) {
         return sRepeatPost("https", json, options, timeLimit, repeatCount, repeatTime, verifyFn);
@@ -146,13 +143,13 @@ var UtilCom;
     /**重复一个 http POST请求并接受数据
      * Object ()
      * @async
-     * @param {JObject} json 	        - 数据对象
-     * @param {Object} options          - 参数对象
-     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
-     * @param {number} [repeatCount]    - 重试次数
-     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
-     * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
-     * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
+     * @param json 	      - 数据对象
+     * @param options     - 参数对象
+     * @param timeLimit   - 超时时间/秒  最小为10秒
+     * @param repeatCount - 重试次数
+     * @param repeatTime  - 超时时间/秒  最小为10秒
+     * @param verifyFn    - 判断有效性函数
+     * @returns 结果 null 为未能成功接收
      */
     function shttpRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, verifyFn) {
         return sRepeatPost("http", json, options, timeLimit, repeatCount, repeatTime, verifyFn);

package/dist/UtilDecorators.d.ts

@@ -1,12 +1,19 @@
+type TDTg<T> = (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+type DTg = (target: Object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
 /**用于打印方法的调用 */
-export declare function DLogger(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function LogCall(): DTg;
 /**用于打印异步方法的调用 */
-export declare function DLoggerAsync(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function LogCallAsync(): DTg;
+/**用于打印方法的调用 */
+export declare function LogErr(): DTg;
+/**用于打印异步方法的调用 */
+export declare function LogErrAsync(): DTg;
 /**try-finally包装 */
-export declare function Defer(deferLogic: () => void): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function Defer<T extends (...args: any) => any>(deferLogic: (...args: Parameters<T>) => any): TDTg<T>;
 /**异步的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;
-/**用于捕获异步方法中的错误 */
-export declare function DCatchErrorsAsync(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function DeferAsync<T extends (...args: any) => Promise<any>>(deferLogic: (...args: Parameters<T>) => any | Promise<any>): TDTg<T>;
+/**try-catch包装 */
+export declare function DCatch<T extends (...args: any) => any>(catchLogic: (error: any, ...args: Parameters<T>) => ReturnType<T>): TDTg<T>;
+/**异步的try-catch包装 */
+export declare function CatchAsync<T extends (...args: any) => Promise<any>>(catchLogic: (error: any, ...args: Parameters<T>) => ReturnType<T>): TDTg<T>;
+export {};

package/dist/UtilDecorators.js

@@ -9,32 +9,70 @@ 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.DeferAsync = exports.Defer = exports.DLoggerAsync = exports.DLogger = void 0;
+exports.CatchAsync = exports.DCatch = exports.DeferAsync = exports.Defer = exports.LogErrAsync = exports.LogErr = exports.LogCallAsync = exports.LogCall = void 0;
 const UtilLogger_1 = require("./UtilLogger");
 /**用于打印方法的调用 */
-function DLogger() {
+function LogCall() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = function (...args) {
             let result = originalMethod.apply(this, args);
-            UtilLogger_1.SLogger.info(`Call: ${propertyKey}(${args}) => ${result}`);
+            UtilLogger_1.SLogger.info(`调用函数: ${propertyKey}(${args}) => ${result}`);
             return result;
         };
+        return descriptor;
     };
 }
-exports.DLogger = DLogger;
+exports.LogCall = LogCall;
 /**用于打印异步方法的调用 */
-function DLoggerAsync() {
+function LogCallAsync() {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = async function (...args) {
             let result = await originalMethod.apply(this, args);
-            UtilLogger_1.SLogger.info(`Call: ${propertyKey}(${args}) => ${result}`);
+            UtilLogger_1.SLogger.info(`调用函数: ${propertyKey}(${args}) => ${result}`);
             return result;
         };
+        return descriptor;
+    };
+}
+exports.LogCallAsync = LogCallAsync;
+/**用于打印方法的调用 */
+function LogErr() {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            try {
+                const result = originalMethod.apply(this, args);
+                return result;
+            }
+            catch (err) {
+                UtilLogger_1.SLogger.warn(`函数出现错误: ${propertyKey}(${args}): ${err}`);
+                throw err;
+            }
+        };
+        return descriptor;
     };
 }
-exports.DLoggerAsync = DLoggerAsync;
+exports.LogErr = LogErr;
+/**用于打印异步方法的调用 */
+function LogErrAsync() {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            try {
+                const result = await originalMethod.apply(this, args);
+                return result;
+            }
+            catch (err) {
+                UtilLogger_1.SLogger.warn(`函数出现错误: ${propertyKey}(${args}): ${err}`);
+                throw err;
+            }
+        };
+        return descriptor;
+    };
+}
+exports.LogErrAsync = LogErrAsync;
 /**try-finally包装 */
 function Defer(deferLogic) {
     return function (target, propertyKey, descriptor) {
@@ -42,12 +80,10 @@ function Defer(deferLogic) {
         descriptor.value = function (...args) {
             try {
                 const result = originalMethod.apply(this, args);
-                deferLogic();
                 return result;
             }
-            catch (e) {
-                deferLogic();
-                throw e;
+            finally {
+                deferLogic(...args);
             }
         };
         return descriptor;
@@ -61,48 +97,53 @@ function DeferAsync(deferLogic) {
         descriptor.value = async function (...args) {
             try {
                 const result = await originalMethod.apply(this, args);
-                deferLogic();
+                await deferLogic(...args);
                 return result;
             }
-            catch (e) {
-                deferLogic();
-                throw e;
+            finally {
+                await deferLogic(...args);
             }
         };
         return descriptor;
     };
 }
 exports.DeferAsync = DeferAsync;
-/**用于捕获方法中的错误 */
-function DCatchErrors() {
+/**try-catch包装 */
+function DCatch(catchLogic) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = function (...args) {
             try {
-                originalMethod.apply(this, args);
+                const result = originalMethod.apply(this, args);
+                return result;
             }
             catch (err) {
-                UtilLogger_1.SLogger.warn(`Error in method ${propertyKey}: ${err}`);
+                //SLogger.warn(`一个函数出现了错误 ${propertyKey}: ${err}`);
+                return catchLogic(err, ...args);
             }
         };
+        return descriptor;
     };
 }
-exports.DCatchErrors = DCatchErrors;
-/**用于捕获异步方法中的错误 */
-function DCatchErrorsAsync() {
+exports.DCatch = DCatch;
+/**异步的try-catch包装 */
+function CatchAsync(catchLogic) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
         descriptor.value = async function (...args) {
             try {
-                await originalMethod.apply(this, args);
+                const result = await originalMethod.apply(this, args);
+                return result;
             }
             catch (err) {
-                UtilLogger_1.SLogger.warn(`Error in method ${propertyKey}: ${err}`);
+                //SLogger.warn(`一个函数出现了错误 ${propertyKey}: ${err}`);
+                return await catchLogic(err, ...args);
             }
         };
+        return descriptor;
     };
 }
-exports.DCatchErrorsAsync = DCatchErrorsAsync;
+exports.CatchAsync = CatchAsync;
 function AddNumberDecorator(n) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
@@ -117,6 +158,9 @@ class Example {
     myMethod(num) {
         return num;
     }
+    async myMethod1(num, ss) {
+        return 312;
+    }
 }
 __decorate([
     AddNumberDecorator(10),
@@ -124,5 +168,15 @@ __decorate([
     __metadata("design:paramtypes", [Number]),
     __metadata("design:returntype", Number)
 ], Example.prototype, "myMethod", null);
+__decorate([
+    LogCall(),
+    Defer((a, b) => null),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, String]),
+    __metadata("design:returntype", Promise)
+], Example.prototype, "myMethod1", null);
+//let e = new Example();
+//e.myMethod1(1,"");
+//console.log(123);
 //let a = new Example();
 //a.myMethod(10);//?

package/dist/UtilFP.d.ts

@@ -0,0 +1,46 @@
+/**常用函数式编程库 */
+export declare namespace UtilFP {
+    /**柯里化函数类型 */
+    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 : "CurryFunc错误 可选无法被识别" & Error : never;
+    /**柯里化转换
+    * @param {T} fn - 将要转换的函数
+    * @returns {CurryFunc<T>} 柯里化的函数
+    */
+    export function curry<T extends Function>(fn: T): CurryFunc<T>;
+    /**可组合的函数 */
+    type CompFunc<T, R> = (arg: T) => R;
+    /**函数管道组合
+     * 从左到右执行
+     * @param fs - 待组合的函数
+     * @returns 组合完成的函数
+     */
+    export function flow<I>(...fs: CompFunc<I, I>[]): CompFunc<I, I>;
+    export function flow<I, R1>(f1: CompFunc<I, R1>, ...fs: CompFunc<R1, R1>[]): CompFunc<I, R1>;
+    export function flow<I, R1, R2>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, ...fs: CompFunc<R2, R2>[]): CompFunc<I, R2>;
+    export function flow<I, R1, R2, R3>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, ...fs: CompFunc<R3, R3>[]): CompFunc<I, R3>;
+    export function flow<I, R1, R2, R3, R4>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, ...fs: CompFunc<R4, R4>[]): CompFunc<I, R4>;
+    export function flow<I, R1, R2, R3, R4, R5>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, ...fs: CompFunc<R5, R5>[]): CompFunc<I, R5>;
+    export function flow<I, R1, R2, R3, R4, R5, R6>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, ...fs: CompFunc<R6, R6>[]): CompFunc<I, R6>;
+    export function flow<I, R1, R2, R3, R4, R5, R6, R7>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, ...fs: CompFunc<R7, R7>[]): CompFunc<I, R7>;
+    export function flow<I, R1, R2, R3, R4, R5, R6, R7, R8>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, f8: CompFunc<R7, R8>, ...fs: CompFunc<R8, R8>[]): CompFunc<I, R8>;
+    export function flow<I, R1, R2, R3, R4, R5, R6, R7, R8, R9>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, f8: CompFunc<R7, R8>, f9: CompFunc<R8, R9>, ...fs: CompFunc<R9, R9>[]): CompFunc<I, R9>;
+    /**函数管道
+     * 从左到右执行
+     * @param input - 初始输入值
+     * @param fs    - 待组合的函数
+     * @returns 经过所有函数处理后的结果
+     */
+    export function pipe<I>(input: I, ...fs: CompFunc<I, I>[]): I;
+    export function pipe<I, R1>(input: I, f1: CompFunc<I, R1>, ...fs: CompFunc<R1, R1>[]): R1;
+    export function pipe<I, R1, R2>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, ...fs: CompFunc<R2, R2>[]): R2;
+    export function pipe<I, R1, R2, R3>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, ...fs: CompFunc<R3, R3>[]): R3;
+    export function pipe<I, R1, R2, R3, R4>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, ...fs: CompFunc<R4, R4>[]): R4;
+    export function pipe<I, R1, R2, R3, R4, R5>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, ...fs: CompFunc<R5, R5>[]): R5;
+    export function pipe<I, R1, R2, R3, R4, R5, R6>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, ...fs: CompFunc<R6, R6>[]): R6;
+    export function pipe<I, R1, R2, R3, R4, R5, R6, R7>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, ...fs: CompFunc<R7, R7>[]): R7;
+    export function pipe<I, R1, R2, R3, R4, R5, R6, R7, R8>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, f8: CompFunc<R7, R8>, ...fs: CompFunc<R8, R8>[]): R8;
+    export function pipe<I, R1, R2, R3, R4, R5, R6, R7, R8, R9>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, f8: CompFunc<R7, R8>, f9: CompFunc<R8, R9>, ...fs: CompFunc<R9, R9>[]): R9;
+    /**将一个字段加入一个对象中，返回新类型 */
+    export function bindTo<K extends string, T, B extends {} = {}>(key: K, value: T, base?: B): B & Record<K, T>;
+    export {};
+}

package/dist/UtilFP.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UtilFP = void 0;
+/**常用函数式编程库 */
+var UtilFP;
+(function (UtilFP) {
+    /**柯里化转换
+    * @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);
+        });
+    }
+    UtilFP.curry = curry;
+    function flow(...fs) {
+        return (arg) => {
+            return fs.reduce((value, func) => func(value), arg);
+        };
+    }
+    UtilFP.flow = flow;
+    function pipe(input, ...fs) {
+        return fs.reduce((value, func) => func(value), input);
+    }
+    UtilFP.pipe = pipe;
+    /**将一个字段加入一个对象中，返回新类型 */
+    function bindTo(key, value, base) {
+        let out = base;
+        out = out ?? {};
+        out[key] = value;
+        return out;
+    }
+    UtilFP.bindTo = bindTo;
+    /**
+    let asd = bindTo("sss",123,{abc:223});//?
+    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));
+     */
+})(UtilFP = exports.UtilFP || (exports.UtilFP = {}));