@zwa73/utils 1.0.76 → 1.0.78

package/dist/QuickFunction.d.ts

@@ -0,0 +1,15 @@
+import { ExtractOutcome, Keyable, Outcome } from "./UtilInterfaces";
+/**创建一个outcome */
+export declare function outcome<K extends Keyable, V>(key: K, value: V): Outcome<K, V>;
+/**处理联合 简单值
+ * @param t       - 目标值
+ * @param procObj - 所有可能的id组成的处理函数映射
+ * @returns 任意处理函数的返回值
+ */
+export declare function match<T extends Keyable | Outcome<Keyable, unknown>, P extends (T extends Keyable ? {
+    [K in T]: (k: K) => unknown;
+} : T extends Outcome<Keyable, unknown> ? {
+    [K in T['status']]: (k: K, v: ExtractOutcome<T, K>['result']) => unknown;
+} : never)>(t: T, procObj: P): P extends Record<any, (...args: any) => any> ? {
+    [K in keyof P]: ReturnType<P[K]>;
+}[keyof P] : never;

package/dist/QuickFunction.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.match = exports.outcome = void 0;
+/**创建一个outcome */
+function outcome(key, value) {
+    return { status: key, result: value };
+}
+exports.outcome = outcome;
+/**处理联合 简单值
+ * @param t       - 目标值
+ * @param procObj - 所有可能的id组成的处理函数映射
+ * @returns 任意处理函数的返回值
+ */
+function match(t, procObj) {
+    if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol')
+        return procObj[t](t);
+    else
+        return procObj[t.status](t.status, t.result);
+}
+exports.match = match;
+if (false) {
+    let a = null;
+    const r = match(a, {
+        "asd": (a) => "ssa",
+        "dsa": (b) => "ssb",
+    });
+}

package/dist/UtilCom.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilCom = void 0;
-const UtilInterfaces_1 = require("./UtilInterfaces");
 const https = require("https");
 const http = require("http");
 const UtilLogger_1 = require("./UtilLogger");
@@ -21,7 +20,7 @@ var UtilCom;
         const hasTimeLimit = (timeLimit >= 10);
         if (hasTimeLimit)
             timeLimit *= 1000;
-        const jsonStr = (0, UtilInterfaces_1.stringifyJToken)(json);
+        const jsonStr = UtilFunctions_1.UtilFunc.stringifyJToken(json);
         const funcName = `s${posttype}Psot`;
         return new Promise((resolve, rejecte) => {
             const resFunc = (res) => {
@@ -51,7 +50,7 @@ var UtilCom;
                         }
                         try {
                             let obj = JSON.parse(resdata);
-                            UtilLogger_1.SLogger.http(funcName + " 接受信息:", (0, UtilInterfaces_1.stringifyJToken)(obj));
+                            UtilLogger_1.SLogger.http(funcName + " 接受信息:", UtilFunctions_1.UtilFunc.stringifyJToken(obj));
                             resolve(obj);
                             return;
                         }

package/dist/UtilDecorators.d.ts

@@ -1,5 +1,15 @@
 type TDTg<T> = (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
 type DTg = (target: Object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**用于打印方法运行时间
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+export declare function LogTime(flag: string, suffixUID?: boolean): DTg;
+/**用于打印异步方法运行时间
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+export declare function LogTimeAsync(flag: string, suffixUID?: boolean): DTg;
 /**用于打印方法的调用 */
 export declare function LogCall(): DTg;
 /**用于打印异步方法的调用 */

package/dist/UtilDecorators.js

@@ -9,8 +9,45 @@ 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.CatchAsync = exports.DCatch = exports.DeferAsync = exports.Defer = exports.LogErrAsync = exports.LogErr = exports.LogCallAsync = exports.LogCall = void 0;
+exports.CatchAsync = exports.DCatch = exports.DeferAsync = exports.Defer = exports.LogErrAsync = exports.LogErr = exports.LogCallAsync = exports.LogCall = exports.LogTimeAsync = exports.LogTime = void 0;
+const UtilFunctions_1 = require("./UtilFunctions");
 const UtilLogger_1 = require("./UtilLogger");
+/**用于打印方法运行时间
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+function LogTime(flag, suffixUID) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const uid = suffixUID ? UtilFunctions_1.UtilFunc.genUUID() : "";
+            UtilLogger_1.SLogger.time(flag + uid);
+            let result = originalMethod.apply(this, args);
+            UtilLogger_1.SLogger.timeEnd(flag + uid);
+            return result;
+        };
+        return descriptor;
+    };
+}
+exports.LogTime = LogTime;
+/**用于打印异步方法运行时间
+ * @param flag      - 时间标签
+ * @param suffixUID - 是否尾随uid
+ */
+function LogTimeAsync(flag, suffixUID) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            const uid = suffixUID ? UtilFunctions_1.UtilFunc.genUUID() : "";
+            UtilLogger_1.SLogger.time(flag + uid);
+            let result = await originalMethod.apply(this, args);
+            UtilLogger_1.SLogger.timeEnd(flag + uid);
+            return result;
+        };
+        return descriptor;
+    };
+}
+exports.LogTimeAsync = LogTimeAsync;
 /**用于打印方法的调用 */
 function LogCall() {
     return function (target, propertyKey, descriptor) {
@@ -158,7 +195,7 @@ class Example {
     myMethod(num) {
         return num;
     }
-    async myMethod1(num, ss) {
+    static async myMethod1(num, ss) {
         return 312;
     }
 }
@@ -174,7 +211,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Number, String]),
     __metadata("design:returntype", Promise)
-], Example.prototype, "myMethod1", null);
+], Example, "myMethod1", null);
 //let e = new Example();
 //e.myMethod1(1,"");
 //console.log(123);

package/dist/UtilFP.js

@@ -16,12 +16,14 @@ var UtilFP;
         });
     }
     UtilFP.curry = curry;
+    //#endregion
     function flow(...fs) {
         return (arg) => {
             return fs.reduce((value, func) => func(value), arg);
         };
     }
     UtilFP.flow = flow;
+    //#endregion
     function pipe(input, ...fs) {
         return fs.reduce((value, func) => func(value), input);
     }

package/dist/UtilFileTools.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilFT = void 0;
 const fs = require("fs");
 const path = require("path");
-const UtilInterfaces_1 = require("./UtilInterfaces");
 const UtilLogger_1 = require("./UtilLogger");
 const JSON5 = require("json5");
 const glob_1 = require("glob");
+const UtilFunctions_1 = require("./UtilFunctions");
 /**文件工具 */
 var UtilFT;
 (function (UtilFT) {
@@ -149,7 +149,7 @@ var UtilFT;
      * @param token    - 所要写入的JToken
      */
     async function writeJSONFile(filePath, token) {
-        let str = (0, UtilInterfaces_1.stringifyJToken)(token);
+        let str = UtilFunctions_1.UtilFunc.stringifyJToken(token);
         if (path.extname(filePath) !== '.json')
             filePath += '.json';
         // 判断文件路径是否存在 不存在则创建

package/dist/UtilFunctions.d.ts

@@ -1,10 +1,13 @@
-import { ComposedClass, ComposedMixinable, JObject, JToken, Mixinable, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
+import { ComposedClass, ComposedMixinable, IJData, JObject, JToken, Mixinable, Outcome, PromiseVerifyFn } from "./UtilInterfaces";
+import { Completed, Timeout } from "./UtilSymbol";
+type CompleteCome<T> = Outcome<Completed, T>;
+type TimeoutCome<T> = Outcome<Timeout, Promise<T>>;
 /**常用函数 */
-export declare namespace UtilFunc {
+export declare class UtilFunc {
     /**获取当前时间戳
      * @returns 时间戳
      */
-    function getTime(): number;
+    static getTime(): number;
     /**初始化对象的字段
      * 会改变obj
      * @param obj        - 所要初始化的对象
@@ -12,59 +15,72 @@ export declare namespace UtilFunc {
      * @param defaultVal - 默认值
      * @returns 最终值
      */
-    function initField<T extends object, K extends keyof T>(obj: T, field: K, defaultVal: T[K]): T[K];
+    static initField<T extends object, K extends keyof T>(obj: T, field: K, defaultVal: T[K]): T[K];
     /**初始化一个数据对象
      * @param obj       - 目标对象
      * @param checkObj  - 用于检测的对象 在对应key缺失时赋予对应值 如果值为函数, 则赋予执行结果 如果结果为 undefined 则不赋值
      * @returns 完成初始化的对象
      */
-    function initObject<T extends JObject>(obj: T, checkObj: {
+    static initObject<T extends JObject>(obj: T, checkObj: {
         [P in keyof T]: T[P] | (() => void | T[P]);
     }): any;
     /**生成一串uuid
      * @returns uuid
      */
-    function genUUID(): string;
+    static genUUID(): string;
     /**计算Hash
      * @param str - 待计算的字符串
      * @returns hash
      */
-    function calcHash(str: string): string;
+    static calcHash(str: string): string;
     /**深克隆 序列化并反序列化
      * @template T - JToken类型的泛型
      * @param obj  - 克隆目标
      * @returns 克隆结果
      */
-    function deepClone<T extends JToken>(obj: T): T;
+    static deepClone<T extends JToken>(obj: T): T;
     /**是否为安全的数字
      * @param num - 所要检测的数字
      * @returns 是否安全
      */
-    function isSafeNumber(num: number): boolean;
+    static isSafeNumber(num: number): boolean;
     /**等待 timeMs 毫秒
      * @async
      * @param timeMs - 等待的毫秒数
      * @returns
      */
-    function sleep(timeMs: number): Promise<boolean>;
+    static sleep<T>(timeMs: number): Promise<void>;
+    /**等待 timeMs 毫秒
+     * @async
+     * @param timeMs - 等待的毫秒数
+     * @param result - 结果
+     * @returns
+     */
+    static sleep<T>(timeMs: number, result: T): Promise<T>;
     /**封装的 cp.exec 执行一段指令 指令完成后返回 Promise
      * @param command 指令文本
      */
-    function exec(command: string): Promise<{
+    static exec(command: string): Promise<{
         stdout: string;
         stderr: string;
     }>;
     /**获得一个永不完成的Promise单例 */
-    function getNeverResolvedPromise<T>(): Promise<T>;
+    static getNeverResolvedPromise<T>(): Promise<T>;
     /**重复尝试promise
      * @async
      * @param procFn      - 发起函数
      * @param verifyFn    - 验证函数
      * @param repeatCount - 重试次数
      * @param repeatTime  - 超时时间/秒  最小为10秒
-     * @returns           - 结果 null 为全部失败/超时
+     * @returns 结果 null 为全部失败/超时
+     */
+    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
+    /**创建一个限时的Promise
+     * @param func      - 处理函数
+     * @param timeLimit - 毫秒限时
+     * @returns 超时则返回 处理函数委托 完成则返回结果
      */
-    function repeatPromise<T>(procFn: PromiseProcFn<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
+    static timelimitPromise<T>(func: () => Promise<T> | T, timeLimit?: number): Promise<CompleteCome<T> | TimeoutCome<T>>;
     /**部分类组合
      * 将mixin的部分字段混入base
      * @param base   - 基础类
@@ -73,14 +89,21 @@ export declare namespace UtilFunc {
      * @param fields - 需要混入的字段
      * @returns 混合完成的类
      */
-    function composeClassPart<Base extends object, Mixin extends object, Field extends keyof Mixin>(base: Base, mixin: Mixin, key: string, ...fields: Field[]): ComposedClass<Base, Mixin, typeof key, Field>;
+    static composeClassPart<Base extends object, Mixin extends object, Field extends keyof Mixin>(base: Base, mixin: Mixin, key: string, ...fields: Field[]): ComposedClass<Base, Mixin, typeof key, Field>;
     /**根据 MIXIN_FIELDS 自动混入 */
-    function composeMixinable<Base extends object, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
+    static composeMixinable<Base extends object, Mixins extends Mixinable<any>[]>(base: Base, ...mixins: Mixins): ComposedMixinable<Base, Mixins>;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象
      * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
-    function mapEntries<T extends Object>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
+    static mapEntries<T extends Object>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
+    /**将JToken转换为字符串
+     * @param token - 待转换的Token
+     * @param space - 插入的空格 数字为空格数量 默认为制表符\t
+     * @returns 转换完成的字符串
+     */
+    static stringifyJToken(token: JToken | IJData, space?: string | number | null | undefined): string;
 }
+export {};