@zwa73/utils 1.0.206 → 1.0.208

package/dist/UtilFunctions.js

@@ -15,12 +15,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-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 __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -28,9 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -38,57 +29,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilFunc = void 0;
 const crypto = __importStar(require("crypto"));
 const cp = __importStar(require("child_process"));
-const UtilLogger_1 = require("./UtilLogger");
 const UtilSymbol_1 = require("./UtilSymbol");
-const UtilDecorators_1 = require("./UtilDecorators");
 const path_1 = __importDefault(require("path"));
 const UtilFileTools_1 = require("./UtilFileTools");
-const util_1 = require("util");
+const UtilLogger_1 = require("./UtilLogger");
+const js_utils_1 = require("@zwa73/js-utils");
+const modular_mixer_1 = require("@zwa73/modular-mixer");
 const HashMethodList = ["md5", "sha1", "sha256", "sha512", "sha3", "blake2", "blake3"];
-/**永不完成的Promise单例 */
-const NeverResolvedPromise = new Promise(() => { });
 /**常用函数 */
-class UtilFunc {
-    //#region 杂项
-    /**获取当前时间戳
-     * @returns 时间戳
-     */
-    static getTime() {
-        return new Date().getTime();
-    }
-    /**初始化对象的字段
-     * 会改变obj
-     * @param obj        - 所要初始化的对象
-     * @param field      - 所要初始化的字段
-     * @param defaultVal - 默认值
-     * @returns 最终值
-     */
-    static initField(obj, field, defaultVal) {
-        if (!(field in obj))
-            obj[field] = defaultVal;
-        return obj[field];
-    }
-    /**初始化一个数据对象
-     * @param obj       - 目标对象
-     * @param checkObj  - 用于检测的对象 在对应key缺失时赋予对应值 如果值为函数, 则赋予执行结果 如果结果为 undefined 则不赋值
-     * @returns 完成初始化的对象
-     */
-    static initObject(obj, checkObj) {
-        const fixobj = obj;
-        for (const key in checkObj) {
-            if (obj[key] !== undefined)
-                continue;
-            const checkVal = checkObj[key];
-            if (typeof checkVal === "function") {
-                const val = checkVal();
-                if (val !== undefined)
-                    fixobj[key] = val;
-            }
-            else
-                fixobj[key] = checkVal;
-        }
-        return fixobj;
-    }
+class _UtilFunc {
     /**生成一串uuid
      * @returns uuid
      */
@@ -103,13 +52,6 @@ class UtilFunc {
     static calcHash(str, method = 'md5') {
         return crypto.createHash(method).update(str).digest('hex');
     }
-    static async sleep(timeMs, result) {
-        return new Promise((resolve, rejecte) => {
-            const timer = setTimeout(() => {
-                resolve(result);
-            }, timeMs);
-        });
-    }
     /**是否需要检查环境 */
     static checkEnv = true;
     /**是否有正在运行的exec */
@@ -128,16 +70,16 @@ class UtilFunc {
             const env = Object.create(process.env);
             const penv = path_1.default.join(opt?.nodeModules
                 ? UtilFileTools_1.UtilFT.currosizePath(opt.nodeModules)
-                : UtilFileTools_1.UtilFT.currosizePath(await UtilFunc.memoize(UtilFileTools_1.UtilFT.findNodeModulesDir)(process.cwd()) ?? ''), '.bin');
-            if (UtilFunc.checkEnv && !await UtilFileTools_1.UtilFT.pathExists(penv)) {
+                : UtilFileTools_1.UtilFT.currosizePath(await exports.UtilFunc.memoize(UtilFileTools_1.UtilFT.findNodeModulesDir)(process.cwd()) ?? ''), '.bin');
+            if (_UtilFunc.checkEnv && !await UtilFileTools_1.UtilFT.pathExists(penv)) {
                 UtilLogger_1.SLogger.warn(`UtilFunc.exec 错误, 没有检测到 node_modules/.bin 环境 penv:${penv}`);
-                UtilFunc.checkEnv = false;
+                _UtilFunc.checkEnv = false;
             }
             env.PATH = penv + path_1.default.delimiter + env.PATH;
             // 保存原来的标题
-            UtilFunc.originalExecTitle = UtilFunc.originalExecTitle == UtilSymbol_1.None
+            _UtilFunc.originalExecTitle = _UtilFunc.originalExecTitle == UtilSymbol_1.None
                 ? process.title
-                : UtilFunc.originalExecTitle;
+                : _UtilFunc.originalExecTitle;
             const cwd = opt?.cwd ?? process.cwd();
             const child = cp.spawn(command, { shell: true, env, cwd });
             let stdout = '';
@@ -154,9 +96,9 @@ class UtilFunc {
             });
             child.on('error', reject);
             child.on('close', (code) => {
-                if (UtilFunc.originalExecTitle != UtilSymbol_1.None) {
-                    process.title = UtilFunc.originalExecTitle;
-                    UtilFunc.originalExecTitle = UtilSymbol_1.None;
+                if (_UtilFunc.originalExecTitle != UtilSymbol_1.None) {
+                    process.title = _UtilFunc.originalExecTitle;
+                    _UtilFunc.originalExecTitle = UtilSymbol_1.None;
                 }
                 if (code !== 0)
                     UtilLogger_1.SLogger.warn(`UtilFunc.exec 命令:"${command}" 结束 代码为:${code}`);
@@ -164,333 +106,12 @@ class UtilFunc {
             });
         });
     }
-    /**获得一个永不完成的Promise单例 */
-    static async getNeverResolvedPromise() {
-        return NeverResolvedPromise;
-    }
-    /**重复尝试promise
-     * @async
-     * @param proc      - 发起函数
-     * @param verify    - 验证函数
-     * @param retries         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
-     * @returns 重复结果
-     */
-    static async retryPromise(proc, verify, retries = {}) {
-        retries.count = retries.count ?? 3;
-        retries.tryInterval = retries.tryInterval ?? 180_000;
-        const { count, tryInterval, tryDelay } = retries;
-        /**是否含有超时时间 */
-        const hasRepeatTime = (tryInterval >= 5000);
-        //验证处理函数
-        if (verify === undefined)
-            verify = () => UtilSymbol_1.Success;
-        //进行中的请求
-        const plist = [];
-        //开始处理
-        try {
-            //根据最大重试次数限制进行循环
-            for (let i = 0; i < count;) {
-                if (i > 0 && tryDelay) {
-                    const delay = retries.expBackoff
-                        ? Math.min((Math.pow(2, i) - 1) * tryDelay, retries.expBackoffMax ?? Infinity)
-                        : tryDelay;
-                    await UtilFunc.sleep(delay);
-                }
-                UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 retryPromise`);
-                //如果 plist 中当前下标的任务还未创建 则 创建当前任务
-                if (plist.length < i + 1) {
-                    plist.push(UtilFunc.timelimitPromise(async () => {
-                        const index = i;
-                        const result = await proc();
-                        const stat = await verify(result);
-                        return { result, stat, index };
-                    }, hasRepeatTime ? tryInterval : undefined));
-                }
-                //等待任意任务 或当前计时器完成
-                const currObj = await Promise.race([...plist]);
-                //超时处理
-                if (currObj.status === UtilSymbol_1.Timeout) {
-                    //解除timeout替换原参数
-                    plist[i] = new Promise(async (rslove) => {
-                        const res = await currObj.result;
-                        rslove(UtilFunc.outcome(UtilSymbol_1.Success, res));
-                    });
-                    UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 retryPromise 超时 ${tryInterval} ms 开始重试`);
-                    i++;
-                    continue;
-                }
-                //路由请求状态
-                const postresult = currObj.result;
-                const result = UtilFunc.matchProc(postresult.stat, {
-                    [UtilSymbol_1.Success]() {
-                        UtilLogger_1.SLogger.info(`第 ${postresult.index + 1} 次 retryPromise 成功`);
-                        //非当前
-                        if (postresult.index != i)
-                            UtilLogger_1.SLogger.info(`成功的 promise 非当前 promise 考虑增大重试时间\n当前index: ${i}\n当前重试时间: ${tryInterval}`);
-                        return postresult.result;
-                    },
-                    [UtilSymbol_1.Terminated]() {
-                        UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 retryPromise 终止 停止重试`);
-                        return postresult.result;
-                    },
-                    [UtilSymbol_1.Failed]() {
-                        //抛弃失败
-                        plist[postresult.index] = UtilFunc.getNeverResolvedPromise();
-                        //是当前
-                        if (postresult.index == i) {
-                            UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 retryPromise 失败 开始重试`);
-                            i++;
-                            return UtilSymbol_1.None;
-                        }
-                        //非当前
-                        UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 retryPromise 失败`);
-                        return UtilSymbol_1.None;
-                    },
-                });
-                if (result !== UtilSymbol_1.None)
-                    return {
-                        completed: result,
-                        pending: plist
-                            .filter((p, i) => i != postresult.index)
-                            .filter(p => p != UtilFunc.getNeverResolvedPromise())
-                            .map(async (p) => {
-                            const curObj = await p;
-                            if (curObj.status == UtilSymbol_1.Success) {
-                                const outres = curObj.result;
-                                if (outres.stat == UtilSymbol_1.Success)
-                                    return outres.result;
-                            }
-                            if (curObj.status == UtilSymbol_1.Timeout) {
-                                const outres = await curObj.result;
-                                if (outres.stat == UtilSymbol_1.Success)
-                                    return outres.result;
-                            }
-                            return undefined;
-                        }),
-                    };
-            }
-            //全部失败或超时则返回 全pending
-            UtilLogger_1.SLogger.warn(`${count} 次 retryPromise 尝试均失败`);
-            return {
-                completed: undefined,
-                pending: plist
-                    .filter(p => p != UtilFunc.getNeverResolvedPromise())
-                    .map(async (p) => {
-                    const curObj = await p;
-                    if (curObj.status == UtilSymbol_1.Success) {
-                        const outres = curObj.result;
-                        if (outres.stat == UtilSymbol_1.Success)
-                            return outres.result;
-                    }
-                    if (curObj.status == UtilSymbol_1.Timeout) {
-                        const outres = await curObj.result;
-                        if (outres.stat == UtilSymbol_1.Success)
-                            return outres.result;
-                    }
-                    return undefined;
-                }),
-            };
-        }
-        catch (err) {
-            UtilLogger_1.SLogger.warn(`retryPromise 发生意外错误`, err);
-            return { completed: undefined, pending: [] };
-        }
-    }
-    /**创建一个限时的Promise
-     * @param func      - 处理函数
-     * @param timeLimit - 毫秒限时
-     * @returns 超时则返回 处理函数委托 完成则返回结果
-     */
-    static async timelimitPromise(func, timeLimit) {
-        return new Promise((reslove) => {
-            let clearTimer = null;
-            const procer = (async () => await func())();
-            const procerP = new Promise(async (resolve) => {
-                const res = await procer;
-                resolve(UtilFunc.outcome(UtilSymbol_1.Success, res));
-                if (clearTimer)
-                    clearTimer();
-            });
-            if (timeLimit) {
-                const timerP = new Promise((timeResolve) => {
-                    const timer = setTimeout(() => timeResolve(UtilFunc.outcome(UtilSymbol_1.Timeout, procer)), timeLimit);
-                    clearTimer = () => {
-                        timeResolve(UtilFunc.outcome(UtilSymbol_1.Timeout, procer));
-                        clearInterval(timer);
-                    };
-                });
-                reslove(Promise.race([procerP, timerP]));
-            }
-            else {
-                reslove(procerP);
-            }
-        });
-    }
-    /**对对象的每个属性应用映射函数，并返回一个新的对象。
-     * @template T      - 对象的类型
-     * @param obj       - 要处理的对象
-     * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
-     * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
-     */
-    static mapEntries(obj, mapper) {
-        return Object.entries(obj).reduce((result, [key, value]) => {
-            result[key] = mapper(key, value);
-            return result;
-        }, {});
-    }
-    /**遍历对象的所有字段
-     * @param obj       - 对象
-     * @param callback  - 回调函数
-     */
-    static eachField(obj, callback) {
-        if (obj == null)
-            return;
-        if (typeof obj === 'object' && 'toJSON' in obj && typeof obj.toJSON == 'function') {
-            UtilLogger_1.SLogger.warn('UtilFunc.eachField 错误 无法遍历IJData 已跳过');
-            return;
-        }
-        if (Array.isArray(obj)) {
-            for (const item of obj)
-                UtilFunc.eachField(item, callback);
-            return;
-        }
-        if (typeof obj === 'object') {
-            for (const [k, v] of Object.entries(obj)) {
-                UtilFunc.eachField(v, callback);
-                callback(k, v, obj);
-            }
-        }
-    }
-    /**将JToken转换为字符串
-     * @param token - 待转换的Token
-     * @param opt   - 可选参数
-     * @param opt.space             - 插入的空格 数字为空格数量 默认为制表符\t
-     * @param opt.compress          - 使用紧凑风格 将会用/\uF121\uF122\uF123.+\uF121\uF122\uF123/作为特殊标记, 原始文本内若出现相同格式将会产生错误
-     * @param opt.compressThreshold - 紧凑风格 压缩阈值 默认100
-     * @returns 转换完成的字符串
-     */
-    static stringifyJToken(token, opt) {
-        opt ??= {};
-        let { compress, space, compressThreshold } = opt;
-        space ??= "\t";
-        space = space === null ? undefined : space;
-        compressThreshold ??= 100;
-        if (!compress)
-            return JSON.stringify(token, null, space);
-        const ec = '\uF121\uF122\uF123';
-        const compressReplacer = (key, value) => {
-            if (Array.isArray(value) && value.every(item => typeof item === 'number' || typeof item === 'string' ||
-                typeof item === 'boolean' || item == null))
-                return `${ec}${JSON.stringify(value)}${ec}`;
-            const str = JSON.stringify(value);
-            if (typeof str != 'string')
-                return value;
-            if (str.length <= compressThreshold)
-                return `${ec}${str}${ec}`;
-            return value;
-        };
-        const result = JSON.stringify(token, compressReplacer, space);
-        if (typeof result != 'string')
-            return result;
-        return result.replace(new RegExp(`"${ec}(.*?)${ec}"`, 'g'), (match, p1) => p1.replace(/\\([\\"])/g, '$1'));
-    }
-    /**验证一个变量的类型是否为 T
-     * @template T - 验证类型
-     * @param t    - 验证目标
-     */
-    static assertType(t) { return t; }
-    /**验证一个变量的类型是否为字面量
-     * 仅限浅层
-     * @template T - 验证类型
-     * @param t    - 验证目标
-     */
-    static assertLiteral(t) { return t; }
-    /**深克隆 序列化并反序列化
-     * @template T - JToken类型的泛型
-     * @param obj  - 克隆目标
-     * @returns 克隆结果
-     */
-    static deepClone(obj) {
-        return JSON.parse(JSON.stringify(obj));
-    }
-    /**是否为安全的数字
-     * 非NaN 非null/undefined
-     * 且是数字
-     * @param num - 所要检测的数字
-     * @returns 是否安全
-     */
-    static isSafeNumber(num) {
-        if (num == null)
-            return false;
-        if (typeof num === 'number') {
-            if (isNaN(num))
-                return false;
-            return true;
-        }
-        return false;
-    }
-    /**移除多行字符串中每行开始的最小空格数。
-     *
-     * @param input   - 需要处理的多行 字符串模板 或 字符串。
-     * @param values  - 插入模板字符串中的值。
-     * @returns 返回处理后的字符串，每行开始的空格数已被最小化。
-     *
-     * @example
-     * const name = 'World';
-     * const str = dedent`
-     *     Hello,
-     *         ${name}!
-     * `;
-     * console.log(str);
-     * // 输出：
-     * // Hello,
-     * //     World!
-     */
-    static dedent(input, ...values) {
-        const str = typeof input === 'string'
-            ? input
-            : input.reduce((result, string, i) => result + string + (values[i] ?? ''), '');
-        const lines = str.split('\n');
-        const minIndent = Math.min(...lines.filter(line => line.trim() !== '').map(line => line.search(/\S/)));
-        return lines.map(line => line.slice(minIndent)).join('\n');
-    }
-    /**抛出错误
-     * @param message - 错误信息
-     * @param lvl     - 日志等级
-     * @param opt     - 额外参数
-     */
-    static throwError(message, lvl, opt) {
-        const e = new Error(message);
-        const stackLines = e.stack.split('\n');
-        e.stack = [stackLines[0]].concat(stackLines.slice(2)).join('\n'); // 移除第一行的堆栈信息
-        Object.assign(e, opt);
-        if (lvl) {
-            //SLogger.log(lvl,message);
-            UtilLogger_1.SLogger.log(lvl, e.stack);
-        }
-        throw e;
-    }
-    /**获取函数调用位置 getFunctionLocation
-     * @param stack - 深度 默认1, 即getFuncLoc函数被调用的位置
-     */
-    static getFuncLoc(stack = 1) {
-        const stackLines = new Error().stack.split('\n');
-        const regex = /([a-zA-Z]+?:.+?):(\d+?:\d+)/;
-        //console.log(stackLines)
-        const match = regex.exec(stackLines[stack + 1]);
-        if (match) {
-            const filePath = match[1];
-            const lineNumber = match[2];
-            return { filePath, lineNumber };
-        }
-        return undefined;
-    }
     static publicIp;
     /**获取当前公网ipv4 */
     static async getPublicIpv4() {
-        if (UtilFunc.publicIp === undefined)
-            UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip');
-        return UtilFunc.publicIp.publicIpv4();
+        if (_UtilFunc.publicIp === undefined)
+            _UtilFunc.publicIp = await _UtilFunc.dynamicImport('public-ip');
+        return _UtilFunc.publicIp.publicIpv4();
     }
     /**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。
      * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。
@@ -511,297 +132,27 @@ class UtilFunc {
     static async dynamicImport(moduleName) {
         return await eval(`import('${moduleName}')`);
     }
-    /**缓存池 */
-    static cachePool = new WeakMap();
-    /**创建一个带有缓存有效期的memoize函数
-     * 只在传入值均为JToken时有效
-     * @param fn     - 需要被memoize的函数
-     * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
-     * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
-     */
-    static memoize(fn, expiry = Infinity) {
-        const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(() => {
-            const c = new Map();
-            UtilFunc.cachePool.set(fn, c);
-            return c;
-        });
-        return ((...args) => {
-            const key = JSON.stringify(args);
-            const now = Date.now();
-            const cached = cache.get(key);
-            if (cached && now - cached.timestamp < expiry)
-                return cached.result;
-            const result = fn(...args);
-            cache.set(key, { result, timestamp: now });
-            return result;
-        });
-    }
-    //#endregion
-    //#region 队列处理
-    /**代办表 用于队列处理等待 */
-    static pendingMap = {};
-    /**队列处理
-     * 等待标签为 flag 的队列
-     * 直到排在之前的任务全部完成再处理当前Promise
-     * @param flag - 队列标签
-     * @param task - 任务逻辑
-     * @returns 处理结果
-     */
-    static async queueProc(flag, task) {
-        // 如果当前标签的队列不存在，则创建一个新的队列
-        if (!UtilFunc.pendingMap[flag])
-            UtilFunc.pendingMap[flag] = [];
-        // 创建一个新的Promise，并保存resolve函数以便后续调用
-        let resolveFunc;
-        let rejectFunc;
-        const promise = new Promise((resolve, reject) => {
-            resolveFunc = resolve;
-            rejectFunc = reject;
-        });
-        // 定义处理任务的函数
-        const processTask = async () => {
-            let result;
-            try {
-                // 执行任务并等待结果
-                result = await task();
-                // 使用保存的resolve函数来解决Promise
-                resolveFunc(result);
-            }
-            catch (error) {
-                // 如果任务执行出错，记录错误日志
-                UtilLogger_1.SLogger.warn(`queueProc 错误 flag: ${String(flag)} 已抛出`);
-                rejectFunc(error);
-            }
-            finally {
-                // 无论任务是否成功，都从队列中移除当前任务
-                UtilFunc.pendingMap[flag].shift();
-                // 如果队列中还有任务，执行下一个任务
-                if (UtilFunc.pendingMap[flag].length > 0) {
-                    UtilFunc.pendingMap[flag][0]();
-                }
-                else {
-                    // 如果队列中没有任务，删除队列
-                    delete UtilFunc.pendingMap[flag];
-                }
-            }
-        };
-        // 将处理任务的函数添加到队列中
-        UtilFunc.pendingMap[flag].push(processTask);
-        // 如果队列中只有当前任务，立即执行
-        if (UtilFunc.pendingMap[flag].length === 1)
-            void processTask();
-        // 返回Promise，以便调用者可以等待任务完成
-        return promise;
-    }
-    /**队列获取目标的代办事件数
-     * @param flag - 队列标签
-     */
-    static queueLength(flag) {
-        const pd = UtilFunc.pendingMap[flag];
-        return pd != null ? pd.length : 0;
-    }
-    //#endregion
-    //#region symbol化处理工具
-    /**创建一个Outcome */
-    static outcome(key, value) {
-        return {
-            status: key,
-            result: value
-        };
-    }
-    /**处理联合值
-     * @param t       - 目标值
-     * @param procObj - 所有可能的id组成的处理函数映射 (status, result)=>any
-     * @returns 任意处理函数的返回值
-     */
-    static matchProc(t, procObj) {
-        if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol') {
-            if (procObj[t])
-                return procObj[t](t);
-        }
-        else if (procObj[t.status])
-            return procObj[t.status](t.status, t.result);
-        UtilFunc.throwError(`matchProc 传入了一个预料之外的值: ${String(t)}`, 'fatal');
-    }
-    /**处理部分联合值
-     * @param t       - 目标值
-     * @param procObj - 所有可能的id组成的处理函数映射 (status, result)=>any
-     * @returns 任意处理函数的返回值
-     */
-    static matchPartialProc(t, procObj) {
-        if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol') {
-            if (procObj[t])
-                return procObj[t](t);
-            else
-                return undefined;
-        }
-        else if (procObj[t.status])
-            return procObj[t.status](t.status, t.result);
-        UtilLogger_1.SLogger.warn(`matchPartialProc 传入了一个预料之外的值, 已返回undefined: ${String(t)}`);
-        return undefined;
-    }
-    /**根据典型的成功或失败状态运行函数
-     * @param t - 目标值
-     * @param sucessFunc - 成功则运行的函数 (result)=>any
-     * @param failedFunc - 失败则运行的函数 (result)=>any
-     * @param noneFunc   - 无结果或不匹配时运行的函数 ()=>any
-     * @returns 非成功或失败时返回 None
-     */
-    static sucesProc(t, sucessFunc, failedFunc, noneFunc) {
-        failedFunc = failedFunc ?? (() => UtilSymbol_1.None);
-        noneFunc = noneFunc ?? (() => UtilSymbol_1.None);
-        const val = typeof t === 'symbol' ? undefined : t.result;
-        if (UtilFunc.isSuccess(t))
-            return sucessFunc(val);
-        if (UtilFunc.isFailed(t))
-            return failedFunc(val);
-        if (t !== UtilSymbol_1.None)
-            UtilLogger_1.SLogger.warn(`sucesProc 传入了一个不匹配的值, 将作为None运行: `, t);
-        return noneFunc();
-    }
-    /**是失败的 */
-    static isFailed(tg) {
-        const test = (t) => t === UtilSymbol_1.Failed || t === UtilSymbol_1.Terminated || t === UtilSymbol_1.Timeout;
-        if (tg != null && typeof tg === 'object' && 'status' in tg)
-            return test(tg.status);
-        return test(tg);
-    }
-    /**是成功的 */
-    static isSuccess(tg) {
-        const test = (t) => t === UtilSymbol_1.Success || t === UtilSymbol_1.Completed;
-        if (tg != null && typeof tg === 'object' && 'status' in tg)
-            return test(tg.status);
-        return test(tg);
-    }
-    /**类似空值  undefined null None
-     * @param t          - 检测目标
-     * @param strictLog  - 应该严格等于None 否则将输出警告 但任然返回true
-     */
-    static likeNone(t, strictLog = true) {
-        if (t === UtilSymbol_1.None)
-            return true;
-        if (t === "null" || t === "undefined" || t === String(UtilSymbol_1.None)) {
-            UtilLogger_1.SLogger.warn(`输入值为字符串类型的空值, 已作为 None 处理`, `具体值: ${t}`);
-            return true;
-        }
-        if (strictLog && t == null)
-            UtilLogger_1.SLogger.warn(`输入值不严格等于 None , 已作为 None 处理`, `具体类型: ${t}`);
-        return t == null;
-    }
-    /**验证一个值是否为空
-     * 为空则抛异
-     * @param t      - 验证目标
-     * @param errLog - 异常信息
-     * @returns 排除None的原值
-     */
-    static expect(t, errLog) {
-        if (t === UtilSymbol_1.None)
-            UtilFunc.throwError(errLog ?? "expect验证了一个None值", "error");
-        return t;
-    }
-    //#endregion
-    //#region 显式处理错误工具
-    /**将传入函数包装为显式处理错误的函数
-     * @param func - 待转换函数
-     * @returns 转换完成的函数
-     */
-    static eitherize(func) {
-        return (...args) => {
-            try {
-                const result = func(...args);
-                return UtilFunc.outcome(UtilSymbol_1.Success, result);
-            }
-            catch (error) {
-                if (error instanceof Error)
-                    return UtilFunc.outcome(UtilSymbol_1.Failed, error);
-                return UtilFunc.outcome(UtilSymbol_1.Failed, new Error((0, util_1.inspect)(error)));
-            }
-        };
-    }
-    /**将传入的异步函数包装为显式处理错误的函数
-     * @param func - 待转换函数
-     * @returns 转换完成的函数
-     */
-    static taskEitherize(func) {
-        return async (...args) => {
-            try {
-                const result = await func(...args);
-                return UtilFunc.outcome(UtilSymbol_1.Success, result);
-            }
-            catch (error) {
-                if (error instanceof Error)
-                    return UtilFunc.outcome(UtilSymbol_1.Failed, error);
-                return UtilFunc.outcome(UtilSymbol_1.Failed, new Error((0, util_1.inspect)(error)));
-            }
-        };
-    }
-    //#endregion
-    //#region 解析srt
-    /**将hh:mm:ss,ms格式转换为毫秒 */
-    static parseSrtTime(time) {
-        const [hours, minutes, seconds] = time.split(':');
-        const [secs, milliseconds] = seconds.split(',');
-        return parseInt(hours) * 3600000 +
-            parseInt(minutes) * 60000 +
-            parseInt(secs) * 1000 +
-            parseInt(milliseconds);
-    }
-    /**将毫秒转换为hh:mm:ss,ms格式 */
-    static formatSrtTime(milliseconds) {
-        const hours = Math.floor(milliseconds / 3_600_000);
-        const minutes = Math.floor((milliseconds % 3_600_000) / 60_000);
-        const seconds = Math.floor((milliseconds % 60_000) / 1000);
-        const ms = Math.floor(milliseconds % 1000);
-        return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')},${String(ms).padStart(3, '0')}`;
-    }
-    /**解析srt文本为SrtSegment[] */
-    static parseSrt(srtText) {
-        const segments = [];
-        const srtLines = srtText.split('\n');
-        let index = 0;
-        while (index < srtLines.length) {
-            const id = srtLines[index++].trim();
-            if (!id)
-                continue;
-            const timeRange = srtLines[index++].trim();
-            const [start, end] = timeRange.split(' --> ')
-                .map(time => UtilFunc.parseSrtTime(time));
-            let text = '';
-            while (index < srtLines.length && srtLines[index].trim())
-                text += `${srtLines[index++]}\n`;
-            index++;
-            segments.push({ start, end, text: text.trim() });
-        }
-        return segments;
-    }
-    /**转换json为srt文本 */
-    static createSrt(segments) {
-        return segments.map((segment, index) => {
-            return `${index + 1}\n${UtilFunc.formatSrtTime(segment.start)} --> ${UtilFunc.formatSrtTime(segment.end)}\n${segment.text}\n`;
-        }).join('\n');
-    }
-    //#endregion
-    //#region 常用直传的快速调用函数
-    /**立即执行传入的函数
-     * @param fn - 需要立即执行的函数。
-     * @returns 返回 fn 函数的执行结果。
-     */
-    static ivk(fn) {
-        return fn();
-    }
-    /**一个可供sort使用的从小到大排序的函数 */
-    static s2l(a, b) {
-        return a - b;
-    }
-    /**一个可供sort使用的从大到小排序的函数 */
-    static l2s(a, b) {
-        return b - a;
-    }
 }
-exports.UtilFunc = UtilFunc;
-__decorate([
-    (0, UtilDecorators_1.LogTimeAsync)("retryPromise ", true),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Function, Function, Object]),
-    __metadata("design:returntype", Promise)
-], UtilFunc, "retryPromise", null);
+const mixkey = '__utilFunc';
+const fields = Object.getOwnPropertyNames(_UtilFunc).filter(k => k !== 'length' && k !== 'prototype' && k !== 'name');
+if (!(mixkey in js_utils_1.JsFunc)) {
+    (0, modular_mixer_1.composeClassPart)({
+        base: js_utils_1.JsFunc,
+        mixin: _UtilFunc,
+        key: mixkey,
+        fields: fields,
+        force: true
+    });
+}
+exports.UtilFunc = js_utils_1.JsFunc;
+//void (async ()=>{
+//    const p1 =  UtilFunc.getNeverResolvedPromise();
+//    const p2 =  UtilFunc.getNeverResolvedPromise();
+//    const p3 =  JsFunc.getNeverResolvedPromise();
+//    const p4 =  JsFunc.getNeverResolvedPromise();
+//    console.log(p1==p2);
+//    console.log(p2==p3);
+//    console.log(p3==p4);
+//    console.log(p3);
+//    console.log(2345);
+//})();