@zwa73/utils 1.0.60 → 1.0.62

package/dist/UtilFunctions.js

@@ -8,19 +8,18 @@ const UtilLogger_1 = require("./UtilLogger");
 var UtilFunc;
 (function (UtilFunc) {
     /**获取当前时间戳
-     * number ()
-     * @returns {number} 时间戳
+     * @returns 时间戳
      */
     function getTime() {
         return new Date().getTime();
     }
     UtilFunc.getTime = getTime;
     /**初始化对象的字段
-     * void (Object,string,any)
-     * @param {Record<string,T>} obj   - 所要初始化的对象
-     * @param {string} field 		   - 所要初始化的字段
-     * @param {T} defaultVal 		   - 默认值
-     * @returns {T} - 最终值
+     * 会改变obj
+     * @param obj        - 所要初始化的对象
+     * @param field 	 - 所要初始化的字段
+     * @param defaultVal - 默认值
+     * @returns 最终值
      */
     function initField(obj, field, defaultVal) {
         if (!(field in obj))
@@ -29,34 +28,32 @@ var UtilFunc;
     }
     UtilFunc.initField = initField;
     /**生成一串uuid
-     * string ()
-     * @returns {string} uuid
+     * @returns uuid
      */
     function genUUID() {
         return crypto.randomBytes(16).toString("hex");
     }
     UtilFunc.genUUID = genUUID;
     /**计算Hash
-     * string ()
-     * @param {string} str - 待计算的字符串
-     * @returns {string} hash
+     * @param str - 待计算的字符串
+     * @returns hash
      */
     function calcHash(str) {
         return crypto.createHash('md5').update(str).digest('hex');
     }
     UtilFunc.calcHash = calcHash;
     /**深克隆 序列化并反序列化
-     * @template {T} T - JToken类型的泛型
-     * @param {T} obj - 克隆目标
-     * @returns {T}   克隆结果
+     * @template T - JToken类型的泛型
+     * @param obj  - 克隆目标
+     * @returns 克隆结果
      */
     function deepClone(obj) {
         return JSON.parse(JSON.stringify(obj));
     }
     UtilFunc.deepClone = deepClone;
     /**是否为安全的数字
-     * @param {number} num - 所要检测的数字
-     * @returns {boolean} 是否安全
+     * @param num - 所要检测的数字
+     * @returns 是否安全
      */
     function isSafeNumber(num) {
         if (num === undefined || num == null || isNaN(num))
@@ -68,8 +65,8 @@ var UtilFunc;
     UtilFunc.isSafeNumber = isSafeNumber;
     /**等待 timeMs 毫秒
      * @async
-     * @param {number} timeMs - 等待的毫秒数
-     * @returns {Promise<boolean>}
+     * @param timeMs - 等待的毫秒数
+     * @returns
      */
     async function sleep(timeMs) {
         return new Promise(function (resolve, rejecte) {
@@ -80,7 +77,7 @@ var UtilFunc;
     }
     UtilFunc.sleep = sleep;
     /**封装的 cp.exec 执行一段指令 指令完成后返回 Promise
-     * @param {string} command 指令文本
+     * @param command 指令文本
      */
     function exec(command) {
         return new Promise((resolve, reject) => {
@@ -102,11 +99,11 @@ var UtilFunc;
     UtilFunc.getNeverResolvedPromise = getNeverResolvedPromise;
     /**重复尝试promise
      * @async
-     * @param {PromiseProcFn<T>} [procFn]       - 发起函数
-     * @param {PromiseVerifyFn<T>} [verifyFn]   - 验证函数
-     * @param {number} [repeatCount]            - 重试次数
-     * @param {number} [repeatTime]             - 超时时间/秒  最小为10秒
-     * @returns {Promise<T|null>}               - 结果 null 为全部失败/超时
+     * @param procFn      - 发起函数
+     * @param verifyFn    - 验证函数
+     * @param repeatCount - 重试次数
+     * @param repeatTime  - 超时时间/秒  最小为10秒
+     * @returns           - 结果 null 为全部失败/超时
      */
     async function repeatPromise(procFn, verifyFn, repeatCount = 3, repeatTime = 180) {
         //计时
@@ -200,46 +197,14 @@ 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 - 混合完成的类
+     * @returns 混合完成的类
      */
-    function composePartClass(base, mixin, ...fields) {
+    function composeClassPart(base, mixin, ...fields) {
         const compObj = base;
         for (const fd of fields) {
             Object.defineProperty(compObj, fd, {
@@ -253,7 +218,7 @@ var UtilFunc;
         }
         return compObj;
     }
-    UtilFunc.composePartClass = composePartClass;
+    UtilFunc.composeClassPart = composeClassPart;
     /**类组合
      * 将mixinList每个成员的字段混入base
      * @param base      - 基础类
@@ -296,11 +261,11 @@ var UtilFunc;
      * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
-    function mapObject(obj, mapper) {
+    function mapEntries(obj, mapper) {
         return Object.entries(obj).reduce((result, [key, value]) => {
             result[key] = mapper(key, value);
             return result;
         }, {});
     }
-    UtilFunc.mapObject = mapObject;
+    UtilFunc.mapEntries = mapEntries;
 })(UtilFunc = exports.UtilFunc || (exports.UtilFunc = {}));

package/dist/UtilInterfaces.d.ts

@@ -15,8 +15,8 @@ export interface IJData {
     toJSON(): JToken;
 }
 /**将JToken转换为字符串
- * @param {JToken|IJData} token - 待转换的Token
- * @param {string|number|null} space - 插入的空格 数字为空格数量 默认为制表符\t
+ * @param token - 待转换的Token
+ * @param space - 插入的空格 数字为空格数量 默认为制表符\t
  * @returns 转换完成的字符串
  */
 export declare function stringifyJToken(token: JToken | IJData, space?: string | number | null | undefined): string;
@@ -68,21 +68,36 @@ 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
+ * @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 ComposedClassPart<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>;
+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> = ComposedClassPart<ComposedClassPart<ComposedClassPart<ComposedClassPart<ComposedClassPart<ComposedClassPart<Base, Mixin1, PropKeys1>, Mixin2, PropKeys2>, Mixin3, PropKeys3>, Mixin4, PropKeys4>, Mixin5, PropKeys5>, Mixin6, PropKeys6>;
 /**组合的类
- * @template {Base}     - 基类
- * @template {Mixin}    - 待混入的类
+ * @template Base     - 基类
+ * @template Mixin    - 待混入的类
  */
 export type ComposedClass<Base extends object, Mixin extends object> = Base & Mixin;
 /**组合的类 多组合变体
- * @template {Base}     - 基类
- * @template {MixinList}- 待混入的类型数组
+ * @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;
+/**将一个类型的所有方法的 `this` 参数改为 `T` 类型
+ * @template Methods - 待更改的函数表
+ * @template T - 目标this类型
+ */
+export type MethodsThisAs<Methods, T> = {
+    [K in keyof Methods]: Methods[K] extends (...args: infer A) => infer R ? (this: T, ...args: A) => R : Methods[K];
+};
+/**尝试断言一个类的原型
+ * 其所有函数的 this 都必须为某个类型
+ * assignThisAs<Self,T>(Self.prototype);
+ * @template Self   - 类的类型
+ * @template T      - 目标this类型
+ * @param prototype - 类的原型
+ */
+export declare function assignThisAs<Self, T>(prototype: MethodsThisAs<Self, T>): void;
 export {};

package/dist/UtilInterfaces.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyJToken = void 0;
+exports.assignThisAs = exports.stringifyJToken = void 0;
 /**将JToken转换为字符串
- * @param {JToken|IJData} token - 待转换的Token
- * @param {string|number|null} space - 插入的空格 数字为空格数量 默认为制表符\t
+ * @param token - 待转换的Token
+ * @param space - 插入的空格 数字为空格数量 默认为制表符\t
  * @returns 转换完成的字符串
  */
 function stringifyJToken(token, space = "\t") {
@@ -12,3 +12,12 @@ function stringifyJToken(token, space = "\t") {
     return JSON.stringify(token, null, space);
 }
 exports.stringifyJToken = stringifyJToken;
+/**尝试断言一个类的原型
+ * 其所有函数的 this 都必须为某个类型
+ * assignThisAs<Self,T>(Self.prototype);
+ * @template Self   - 类的类型
+ * @template T      - 目标this类型
+ * @param prototype - 类的原型
+ */
+function assignThisAs(prototype) { }
+exports.assignThisAs = assignThisAs;

package/dist/UtilLogger.d.ts

@@ -9,16 +9,16 @@ export type HRTimeLog = {
 export type LogLevel = "fatal" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly" | undefined;
 export declare class SLogger {
     /**获取一个Logger，如不存在则用默认参数创建
-     * @param {string} name  - logger的名称 默认default
-     * @returns {SLogger}    - 获取的logger
+     * @param name - logger的名称 默认default
+     * @returns 获取的logger
      */
     static getLogger(name?: string): SLogger;
     /**创建Logger
-     * @param {string} name             - logger的名称 默认default
-     * @param {LogLevel} consoleLevel   - 输出到控制台的最低等级 默认info
-     * @param {string} outFloder        - log的输出文件夹路径 如./log/
-     * @param {LogLevel} fileLevel      - 输出到文件的最低等级   默认info
-     * @returns {SLogger} - 创建完成的logger
+     * @param name         - logger的名称 默认default
+     * @param consoleLevel - 输出到控制台的最低等级 默认info
+     * @param outFloder    - log的输出文件夹路径 如./log/
+     * @param fileLevel    - 输出到文件的最低等级   默认info
+     * @returns 创建完成的logger
      */
     static createLogger(name?: string, consoleLevel?: LogLevel, outFloder?: string, fileLevel?: LogLevel): SLogger;
     private constructor();
@@ -28,119 +28,119 @@ export declare class SLogger {
     /**记录Logger的表 */
     private static readonly timeTable;
     /**产生一条对应等级的log 返回自身
-     * @param {LogLevel} level      - log等级
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger} - 自身
+     * @param level    - log等级
+     * @param messages - log消息
+     * @returns 自身
      */
     log(level: LogLevel, ...messages: Array<any>): SLogger;
     /**产生一条fatal等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     fatal(...messages: Array<any>): SLogger;
     /**产生一条error等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     error(...messages: Array<any>): SLogger;
     /**产生一条warn等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     warn(...messages: Array<any>): SLogger;
     /**产生一条info等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     info(...messages: Array<any>): SLogger;
     /**产生一条http等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     http(...messages: Array<any>): SLogger;
     /**产生一条verbose等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger} - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     verbose(...messages: Array<any>): SLogger;
     /**产生一条debug等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     debug(...messages: Array<any>): SLogger;
     /**产生一条silly等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     silly(...messages: Array<any>): SLogger;
     /**记录当前时间戳并存入表
-     * @param {string} flag     - 记录的命名
-     * @returns {HRTimeLog}     - 记录的时间
+     * @param flag     - 记录的命名
+     * @returns 记录的时间
      */
     time(flag: string): HRTimeLog;
     /**根据之前记录的时间戳计算经过的时间 并输出log
-     * @param {string}   flag       - 记录的命名
-     * @param {LogLevel|null} level - log等级 ===null时不产生log
-     * @returns {string|null}  - 格式化的时间字符串
+     * @param flag  - 记录的命名
+     * @param level - log等级 === null时不产生log
+     * @returns 格式化的时间字符串
      */
     timeEnd(flag: string, level?: LogLevel | null): string | null;
     /**名称为default的slogger实例 */
     private static get defaultInstance();
     /**让名称为default的logger 产生一条对应等级的log 返回自身
-     * @param {LogLevel} level - log等级
-     * @param {Array<any>} messages    - log消息
-     * @returns {SLogger}      - 自身
+     * @param level    - log等级
+     * @param messages -  log消息
+     * @returns 自身
      */
     static log(level: LogLevel, ...messages: Array<any>): SLogger;
     /**让名称为default的logger 产生一条fatal等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     static fatal(...messages: Array<any>): SLogger;
     /**让名称为default的logger 产生一条error等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     static error(...messages: Array<any>): SLogger;
     /**让名称为default的logger 产生一条warn等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     static warn(...messages: Array<any>): SLogger;
     /**让名称为default的logger 产生一条info等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     static info(...messages: Array<any>): SLogger;
     /**让名称为default的logger 产生一条http等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     static http(...messages: Array<any>): SLogger;
     /**让名称为default的logger 产生一条verbose等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     static verbose(...messages: Array<any>): SLogger;
     /**让名称为default的logger 产生一条debug等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     static debug(...messages: Array<any>): SLogger;
     /**让名称为default的logger 产生一条silly等级的log 返回自身
-     * @param {Array<any>} messages - log消息
-     * @returns {SLogger}   - 自身
+     * @param messages - log消息
+     * @returns 自身
      */
     static silly(...messages: Array<any>): SLogger;
     /**让名称为default的logger 记录当前时间戳并存入表
-     * @param {string} flag     - 记录的命名
-     * @returns {HRTimeLog}     - 记录的时间
+     * @param flag - 记录的命名
+     * @returns 记录的时间
      */
     static time(flag: string): HRTimeLog;
     /**让名称为default的logger 根据之前记录的时间戳计算经过的时间 并输出log
-     * @param {string}   flag  - 记录的命名
-     * @param {LogLevel} level - log等级
-     * @returns {void}
+     * @param flag  - 记录的命名
+     * @param level - log等级
+     * @returns
      */
     static timeEnd(flag: string, level?: LogLevel): void;
 }