@zwa73/utils 1.0.46 → 1.0.49

package/dist/UtilFunctions.js

@@ -93,6 +93,7 @@ var UtilFunc;
         });
     }
     UtilFunc.exec = exec;
+    /**永不完成的Promise单例 */
     const NeverResolvedPromise = new Promise(() => { });
     /**获得一个永不完成的Promise单例 */
     function getNeverResolvedPromise() {
@@ -103,11 +104,14 @@ 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) {
+        //计时
+        const timeflag = "repeatPromise " + UtilFunc.genUUID();
+        UtilLogger_1.SLogger.time(timeflag);
         //转换为毫秒
         const hasRepeatTime = (repeatTime >= 10);
         if (hasRepeatTime)
@@ -130,58 +134,173 @@ var UtilFunc;
             resolveFn = null;
         };
         //进行中的请求
-        const plist = new Array(repeatCount)
-            .fill(UtilFunc.getNeverResolvedPromise());
-        for (let i = 0; i < repeatCount;) {
-            UtilLogger_1.SLogger.info("开始第 " + (i + 1) + " 次 repeatPromise");
-            //创建当前任务
-            plist[i] = procFn().then(result => ({ result, stat: verifyFn(result), index: i }));
-            //创建定时器
-            if (timerP == null) {
-                timerP = new Promise(function (resolve, rejecte) {
-                    resolveFn = resolve;
-                    timer = setTimeout(() => resolve("Timeout"), hasRepeatTime ? repeatTime : Infinity); //无限制则无限时间
-                });
-            }
-            //等待完成
-            const currObj = await Promise.race([...plist, timerP]);
-            //超时处理
-            if (currObj == "Timeout") {
-                UtilLogger_1.SLogger.warn(`第 ${(i + 1)} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
-                clearTimer();
-                i++;
-                continue;
-            }
-            else {
+        const plist = [];
+        //开始处理
+        try {
+            for (let i = 0; i < repeatCount;) {
+                UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 repeatPromise`);
+                //创建当前任务
+                if (plist.length < i + 1) {
+                    plist.push(procFn().then(result => ({ result, stat: verifyFn(result), index: i })));
+                }
+                //创建定时器
+                if (timerP == null) {
+                    timerP = new Promise(function (resolve, rejecte) {
+                        resolveFn = resolve;
+                        timer = setTimeout(() => resolve("Timeout"), hasRepeatTime ? repeatTime : Infinity); //无限制则无限时间
+                    });
+                }
+                //等待完成
+                const currObj = await Promise.race([...plist, timerP]);
+                //超时处理
+                if (currObj == "Timeout") {
+                    UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
+                    clearTimer();
+                    i++;
+                    continue;
+                }
                 const poststat = await currObj.stat;
                 switch (poststat) {
                     case "Completed": //完成
-                        UtilLogger_1.SLogger.info("第 " + (currObj.index + 1) + " 次 repeatPromise 成功");
-                        clearTimer();
+                        UtilLogger_1.SLogger.info(`第 ${currObj.index + 1} 次 repeatPromise 成功`);
+                        //非当前
+                        if (currObj.index != i)
+                            UtilLogger_1.SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
                         return currObj.result;
                     case "Terminated": //终止
-                        UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 repeatPromise 终止 停止重试");
-                        clearTimer();
+                        UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 终止 停止重试`);
                         return currObj.result;
                     case "Failed": //验证失败
+                        //抛弃失败
+                        plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
                         //是当前
                         if (currObj.index == i) {
-                            UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 repeatPromise 失败 开始重试");
+                            UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 失败 开始重试`);
                             clearTimer();
                             i++;
                             continue;
                         }
                         //非当前
-                        UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 repeatPromise 失败");
-                        //抛弃失败
-                        plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                        UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 失败`);
                         continue;
                 }
             }
+            //全部失败或超时则返回null
+            UtilLogger_1.SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
+            return null;
+        }
+        catch (err) {
+            UtilLogger_1.SLogger.warn(`repeatPromise 发生错误`, err);
+            return null;
+        }
+        finally {
+            //清理
+            clearTimer();
+            UtilLogger_1.SLogger.timeEnd(timeflag);
         }
-        clearTimer();
-        //全部失败或超时则返回null
-        return null;
     }
     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

@@ -54,15 +54,6 @@ type ExclusiveRecursive<B, T, K extends string[], R extends unknown[] = []> = R[
 export type ExclusiveRecord<B, T, K extends string[], TMP = ExclusiveRecursive<B, T, K>> = TMP[keyof TMP];
 /**符合JObject约束的互斥表 */
 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;
-};
 /**请求完成状态 成功/失败/终止
  * 成功/终止 将直接返回
  * 失败 将重试
@@ -72,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 {};

package/dist/test/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/test.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const UtilFunctions_1 = require("../UtilFunctions");
+const compKeys = ["getData", "getA"];
+class A {
+    abc = 223;
+    /**A的getData */
+    getData() {
+        return this.abc;
+    }
+    /**获取A */
+    getA() {
+        return this;
+    }
+}
+class C {
+    abc = 3333;
+    /**A的getData */
+    resetData() {
+        return this.abc;
+    }
+    /**获取C */
+    getC() {
+        return this;
+    }
+    /**获取C */
+    getC1() {
+        return this;
+    }
+}
+class B {
+    _bc;
+    constructor() {
+        const tb = this;
+        this._bc = UtilFunctions_1.UtilFunc.composePartClass(tb, new A(), ...compKeys);
+    }
+    static init() {
+        return new B()._bc;
+    }
+    /**B的getData */
+    getData1() { return "BGetdata"; }
+    getTest() { return this._bc.getData(); }
+}
+const BComp = {
+    init() {
+        return B.init();
+    }
+};
+let c = BComp.init();
+console.log(1);
+let d = c.getData(); //?
+c.getA;
+c.getData1(); //?
+c.getTest(); //?
+let r3 = null;
+class Monster {
+    constructor(a) { }
+    monfunc() {
+        return "mon";
+    }
+}
+class Monster1 {
+    constructor(a) { }
+    m1num = 123;
+    monfunc1() {
+        return "mon1";
+    }
+}
+const OtherMonster = {
+    init() {
+        let mon = new Monster(123);
+        let mon1 = new Monster1(223);
+        let om = {
+            om: "123", mon
+        };
+        return UtilFunctions_1.UtilFunc.composeClass(om, mon, mon1);
+    }
+};
+let om = OtherMonster.init(); //?
+om.monfunc(); //?
+om.monfunc1(); //?
+om.m1num; //?
+const BASE_MAX = { 攻击: 24, 生命: 54, 防御: 16, 暴击: 5, 暴击伤害: 5, 攻击加成: 3.8, 生命加成: 3.8, 防御加成: 3.8 };
+const 精调前 = [
+    { 攻击: 17, 生命: 0, 防御: 0, 暴击: 0, 暴击伤害: 3.5, 攻击加成: 3.0, 生命加成: 0, 防御加成: 3.4 },
+    { 攻击: 19, 生命: 0, 防御: 0, 暴击: 4.5, 暴击伤害: 4.5, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 21, 生命: 0, 防御: 10, 暴击: 0, 暴击伤害: 0, 攻击加成: 3.8, 生命加成: 0, 防御加成: 3.0 },
+    { 攻击: 17, 生命: 48, 防御: 14, 暴击: 0, 暴击伤害: 0, 攻击加成: 2.6, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 23, 生命: 0, 防御: 0, 暴击: 5, 暴击伤害: 0, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 17, 生命: 53, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 21, 生命: 0, 防御: 0, 暴击: 3.5, 暴击伤害: 0, 攻击加成: 3.0, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 17, 生命: 0, 防御: 3.8, 暴击: 0, 暴击伤害: 0, 攻击加成: 2.6, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 19, 生命: 38, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 3.4, 生命加成: 0, 防御加成: 0 }, // 机枪 双重对策 折叠脚架
+];
+const 精调后 = [
+    { 攻击: 26, 生命: 0, 防御: 0, 暴击: 0, 暴击伤害: 8.1, 攻击加成: 7.5, 生命加成: 0, 防御加成: 5.8 },
+    { 攻击: 31, 生命: 0, 防御: 0, 暴击: 10.4, 暴击伤害: 10.4, 攻击加成: 7.5, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 49, 生命: 0, 防御: 17, 暴击: 0, 暴击伤害: 0, 攻击加成: 7.6, 生命加成: 0, 防御加成: 6.9 },
+    { 攻击: 46, 生命: 116, 防御: 27, 暴击: 0, 暴击伤害: 0, 攻击加成: 5.0, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 42, 生命: 0, 防御: 0, 暴击: 11.5, 暴击伤害: 0, 攻击加成: 6.8, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 34, 生命: 101, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 6.5, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 38, 生命: 0, 防御: 0, 暴击: 8.4, 暴击伤害: 0, 攻击加成: 4.8, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 43, 生命: 0, 防御: 8.0, 暴击: 0, 暴击伤害: 0, 攻击加成: 7.3, 生命加成: 0, 防御加成: 0 },
+    { 攻击: 42, 生命: 54, 防御: 0, 暴击: 0, 暴击伤害: 0, 攻击加成: 6.2, 生命加成: 0, 防御加成: 0 }, // 机枪 双重对策 折叠脚架
+];
+const Pointify = (ed) => UtilFunctions_1.UtilFunc.mapObject(ed, (k, v) => v ? v / BASE_MAX[k] : 0);
+const Sump = (ed) => Object.values(ed).reduce((r, v) => r + v);
+const pipeFunc = UtilFunctions_1.UtilFunc.pipeline(Pointify, Sump);
+const Display = (list) => list.reduce((r, v) => `${r}\t${v.toFixed(2)}`, "").trim();
+const pre = 精调前.map((v) => pipeFunc(v));
+const aft = 精调后.map((v) => pipeFunc(v));
+const div = pre.map((dv, i) => aft[i] / dv);
+Display(pre); //?
+Display(aft); //?
+Display(div); //?
+// 定义一个函数，它将作为构造函数
+function MyObject() {
+    // @ts-ignore
+    this.a = 123;
+}
+let asloop = [
+    {
+        type: "effect_of_condition",
+        id: "loop",
+        effect: [
+            { if: { math: ["i", ">", "0"] },
+                then: [
+                    { u_message: "hello world" },
+                    { math: ["i", "-=", "1"] },
+                    { run_eocs: "loop" },
+                ] }
+        ]
+    },
+    {
+        type: "effect_of_condition",
+        id: "main",
+        effect: [
+            { math: ["i", "=", "10"] },
+            { run_eocs: "loop" }
+        ]
+    }
+];
+let asaloop = [
+    {
+        type: "effect_of_condition",
+        id: "loop",
+        effect: [
+            { u_message: "hello world" }
+        ]
+    },
+    {
+        type: "effect_of_condition",
+        id: "main",
+        effect: [
+            {
+                run_eoc_with: "efl",
+                variables: {
+                    i: "0",
+                    length: "10",
+                    eoc: "loop"
+                }
+            }
+        ]
+    }
+];
+const testa = {
+    _a: 123
+};
+Object.defineProperty(testa, 'a', {
+    get: () => 1,
+    set: function (value) {
+        console.log('Set:', value);
+    },
+    enumerable: true
+});
+Object.defineProperty(testa, 'c', {
+    value: 123,
+    writable: true,
+    enumerable: true,
+    configurable: true
+});
+testa.constructor.prototype; //?
+testa; //?
+let testkeys = [];
+for (let k in testa)
+    testkeys.push(k);
+testkeys; //?

package/dist/test/test2.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/test2.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const UtilFileTools_1 = require("../UtilFileTools");
+// 将字符串转换为十六进制
+function stringToHex(str) {
+    const buf = Buffer.from(str, 'utf8');
+    return buf.toString('hex');
+}
+// 将十六进制转换为字符串
+function hexToString(hex) {
+    const buf = Buffer.from(hex, 'hex');
+    return buf.toString('utf8');
+}
+// 示例
+let str = "Hello World";
+let hex = "0B0000002D";
+console.log(stringToHex(str)); // 输出字符串对应的十六进制
+console.log(hexToString(hex)); // 输出十六进制对应的字符串
+hexToString("556E6974794653"); //?
+/**
+首先我有一个文件夹./in
+我在里面存放了一些整合加密的二进制文件，文件名符合正则/.*\.bk/
+我需要你帮我写解密程序，将其解密并分离为单独的文件，接下来我告诉你解密方式:
+读取文件后，我们先用split(hexToString(hex))对文本进行分割成多块，然后在每一块找到第二个"UnityFS"，
+再从第二个UnityFS的开头截取到每一块的末尾
+我举一个例子，假设我们有一段分割完成的文本块 "112233 UnityFS sasasd UnityFS我需要的内容"
+那么它截取完成之后应该是"UnityFS我需要的内容"
+最后，我们在将所有截取完成的文本块作为文件输出到./out/{filename}
+文件名就是 {原文件名+块编号.bs}
+开始写吧
+**/
+path.parse("123.bs").name; //?
+let filepath = "F:\\Sosarciel\\SosarcielCore\\NodeJs\\utils\\src";
+UtilFileTools_1.UtilFT.fileSearchGlob(`${filepath}/**/*.ts`, "**/test/**/*.ts"); //?

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@zwa73/utils",
-  "version": "1.0.46",
+  "version": "1.0.49",
   "description": "my utils",
   "main": "index.js",
   "scripts": {
-    "test": "node test"
+    "test": "node test",
+    "postinstall": "node postinstall.js"
   },
   "keywords": [
     "zwa73"
@@ -16,6 +17,7 @@
     "esm": "^3.2.25",
     "esm-resolve": "^1.0.8",
     "fluent-ffmpeg": "^2.1.2",
+    "glob": "^10.3.10",
     "html-entities": "^2.3.3",
     "http-proxy-agent": "^5.0.0",
     "https-proxy-agent": "^5.0.1",

package/postinstall.js

@@ -0,0 +1,39 @@
+const currentVersion = require('./package.json').version;
+const path = require('path');
+const { UtilFT } = require("./index");
+const dataPath = path.join(__dirname,"..","version.json");
+UtilFT.ensurePathExists(dataPath);
+let dataTable = UtilFT.loadJSONFileSync(dataPath,{});
+dataTable.utils = dataTable.utils??{};
+let prevVersion = dataTable.utils.version;
+dataTable.utils.version = currentVersion;
+
+console.log(`${currentVersion} 版本已安装`);
+
+// 将版本号转换为可以比较的数字
+function versionToNumber(version) {
+    if(version==undefined) return 0;
+    return version.split('.').map(Number).reduce((acc, val) => acc * 1000 + val);
+}
+//提示表
+const infoTable = {
+    "1.0.17":"fileSearch 函数进入 UtilFT 命名空间",
+    "1.0.47":"UtilFT.fileSearch 函数与返回值发生变动, 请使用fileSearchRegex 或 fileSearchGlob"
+}
+//显示提示
+function showUpgradeMessages(prevVersion, currentVersion, infoTable) {
+    let prevVersionNumber = versionToNumber(prevVersion);
+    let currentVersionNumber = versionToNumber(currentVersion);
+    // 遍历infoTable中的所有版本
+    for (let version in infoTable) {
+        let versionNumber = versionToNumber(version);
+        // 如果用户的上一个版本低于这个版本，而当前版本高于或等于这个版本
+        if (versionNumber > prevVersionNumber && versionNumber <= currentVersionNumber) {
+            // 显示这个版本的提示信息
+            console.log(infoTable[version]);
+        }
+    }
+}
+
+// 使用这个函数来显示升级信息
+showUpgradeMessages(prevVersion, currentVersion, infoTable);

package/publish.bat

@@ -1,2 +1,2 @@
-npm publish --access public
+call npm publish --access public
 pause

package/src/UtilClass.ts

@@ -981,3 +981,71 @@ class SKVC {
 
     constructor() {}
 }
+
+/**函数组合器 */
+export class Composer<Result,PreArg = Result> {
+    /**组合函数列表 */
+    private funcs: Function[] = [];
+    private constructor(){};
+    /**添加单个参数与返回值不同的函数 */
+    public static push<Result,Arg>(func: (arg: Arg) => Result): Composer<Result,Arg>;
+    /**添加多个参数与返回值相同的函数 */
+    public static push<Result>(func:((arg: Result) => Result), ...funcs: ((arg: Result) => Result)[]): Composer<Result>;
+    public static push(...funcs: Function[]){
+        const newComposer = new Composer<any>();
+        newComposer.funcs = [...funcs];
+        return newComposer;
+    }
+
+    /**添加单个参数与返回值不同的函数 */
+    public push<T>(func: (arg: T) => PreArg): Composer<Result,T>;
+    /**添加多个参数与返回值相同的函数 */
+    public push(func:((arg: Result) => Result), ...funcs: ((arg: PreArg) => PreArg)[]): Composer<Result,PreArg>;
+    public push(...funcs: Function[]): Composer<Result,any> {
+        const newComposer = new Composer<Result>();
+        newComposer.funcs = [...this.funcs, ...funcs];
+        return newComposer;
+    }
+    /**组合函数 */
+    public compose():(arg:PreArg)=>Result {
+        return (arg:PreArg) => this.funcs.reduceRight((value, func) => func(value), arg) as any as Result;
+    }
+    /**直接调用 */
+    public invoke(arg:PreArg):Result {
+        return this.funcs.reduceRight((value, func) => func(value), arg) as any as Result;
+    }
+}
+/**函数管道器 */
+export class Piper<Arg, Result = Arg> {
+    /**管道函数列表 */
+    private funcs: Function[] = [];
+    private constructor(){};
+    /**添加单个参数与返回值不同的函数 */
+    public static pipe<Arg, Result>(func: (arg: Arg) => Result): Piper<Arg, Result>;
+    /**添加多个参数与返回值相同的函数 */
+    public static pipe<Arg>(func:((arg: Arg) => Arg), ...funcs: ((arg: Arg) => Arg)[]): Piper<Arg>;
+    public static pipe(...funcs: Function[]){
+        const newPiper = new Piper<any>();
+        newPiper.funcs = [...funcs];
+        return newPiper;
+    }
+
+    /**添加单个参数与返回值不同的函数 */
+    public pipe<T>(func: (arg: Result) => T): Piper<Arg, T>;
+    /**添加多个参数与返回值相同的函数 */
+    public pipe(func:((arg: Result) => Result), ...funcs: ((arg: Result) => Result)[]): Piper<Arg, Result>;
+    public pipe(...funcs: Function[]): Piper<Arg, any> {
+        const newPiper = new Piper<Arg>();
+        newPiper.funcs = [...this.funcs, ...funcs];
+        return newPiper;
+    }
+    /**管道函数 */
+    public pipeline():(arg:Arg)=>Result {
+        return (arg:Arg) => this.funcs.reduce((value, func) => func(value), arg) as any as Result;
+    }
+    /**直接调用 */
+    public invoke(arg:Arg):Result {
+        return this.funcs.reduce((value, func) => func(value), arg) as any as Result;
+    }
+}
+