@zwa73/utils 1.0.193 → 1.0.195

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment } from "@/src/UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment, MPromise } from "@/src/UtilInterfaces";
 import * as cp from "child_process";
 import { LogLevel, SLogger } from "@/src/UtilLogger";
 import { Completed, Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Terminated, Timeout } from "./UtilSymbol";
@@ -8,7 +8,6 @@ import opath from 'path';
 import { UtilFT } from "./UtilFileTools";
 import {inspect} from 'util';
 import type * as publicIp from 'public-ip';
-import { ivk } from "./LiteFunction";
 
 const HashMethodList = ["md5","sha1","sha256","sha512","sha3","blake2","blake3"] as const;
 type HashMethod = typeof HashMethodList[number];
@@ -74,6 +73,8 @@ type EachFieldCallback = (key: string, value: JToken,parent: JObject) => void;
 
 /**常用函数 */
 export class UtilFunc{
+
+//#region 杂项
 /**获取当前时间戳  
  * @returns 时间戳
  */
@@ -134,7 +135,6 @@ static calcHash(str:string,method:HashMethod='md5') {
     return crypto.createHash(method).update(str).digest('hex');
 }
 
-
 /**等待 timeMs 毫秒  
  * @async
  * @param timeMs - 等待的毫秒数
@@ -149,8 +149,8 @@ static async sleep<T>(timeMs: number): Promise<void>
  */
 static async sleep<T>(timeMs: number, result:T): Promise<T>
 static async sleep<T>(timeMs: number, result?:T): Promise<T|undefined> {
-    return new Promise(function (resolve, rejecte) {
-        let timer = setTimeout(function () {
+    return new Promise((resolve, rejecte) => {
+        const timer = setTimeout(() => {
             resolve(result);
         }, timeMs);
     });
@@ -356,7 +356,7 @@ Promise<RepeatPromiseResult<T>>{
  * @returns 超时则返回 处理函数委托 完成则返回结果
  */
 static timelimitPromise<T>
-    (func:()=>Promise<T>|T,timeLimit?:number):Promise<SuccessOut<T>|TimeoutOut<T>>{
+    (func:()=>MPromise<T>,timeLimit?:number):Promise<SuccessOut<T>|TimeoutOut<T>>{
     return new Promise<SuccessOut<T>|TimeoutOut<T>>((reslove)=>{
         let clearTimer:(()=>void)| null = null;
         const procer = (async ()=>await func())();
@@ -457,6 +457,167 @@ static stringifyJToken(token:JToken|IJData,opt?:StringifyOpt){
             p1.replace(/\\([\\"])/g, '$1'));
 }
 
+/**验证一个变量的类型是否为 T
+ * @template T - 验证类型
+ * @param t    - 验证目标
+ */
+static assertType<T>(t:T):T{return t;}
+
+/**验证一个变量的类型是否为字面量  
+ * 仅限浅层  
+ * @template T - 验证类型
+ * @param t    - 验证目标
+ */
+static assertLiteral<T>(t:Literal<T>):T{return t as T;}
+
+/**深克隆 序列化并反序列化  
+ * @template T - JToken类型的泛型
+ * @param obj  - 克隆目标
+ * @returns 克隆结果
+ */
+static deepClone<T extends JToken>(obj: T): T {
+    return JSON.parse(JSON.stringify(obj));
+}
+
+/**是否为安全的数字  
+ * 非NaN 非null/undefined  
+ * 且是数字  
+ * @param num - 所要检测的数字
+ * @returns 是否安全
+ */
+static isSafeNumber(num: unknown): boolean {
+    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: TemplateStringsArray|string, ...values: any[]): string {
+    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:string,lvl?:LogLevel,opt?:{}):never{
+    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);
+        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] as `${number}:${number}`;
+        return {filePath,lineNumber}
+    }
+    return undefined;
+}
+
+private static publicIp?:typeof publicIp;
+/**获取当前公网ipv4 */
+static async getPublicIpv4(){
+    if(UtilFunc.publicIp===undefined)
+        UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip') as typeof publicIp;
+    return UtilFunc.publicIp.publicIpv4();
+}
+
+/**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。  
+ * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。  
+ * 请注意，这个函数使用了eval()，可能会带来安全风险。  
+ *
+ * @param moduleName - 需要导入的模块的名称。
+ * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
+ *
+ * @example
+ * async function main() {
+ *   const pip = (await dynamicImport('public-ip')).default;
+ *   console.log(await pip.v4());
+ * }
+ * main();
+ *
+ * @since Node.js 13.2，Node.js开始支持动态import。
+ */
+static async dynamicImport(moduleName:string):Promise<any> {
+    return await eval(`import('${moduleName}')`);
+}
+
+/**缓存池 */
+static cachePool = new WeakMap<Function, Map<string, { result: any, timestamp: number }>>();
+
+/**创建一个带有缓存有效期的memoize函数  
+ * 只在传入值均为JToken时有效
+ * @param fn     - 需要被memoize的函数
+ * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
+ * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
+ */
+static memoize<T extends (...args:any[])=>any> (fn: T, expiry = Infinity):
+    T extends (...args:infer In)=>any
+        ? AllExtends<In,JToken> extends true ? T : never
+        : never {
+    const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(()=>{
+        const c = new Map();
+        UtilFunc.cachePool.set(fn, c);
+        return c;
+    });
+
+    return ((...args: Parameters<T>): ReturnType<T> => {
+        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;
+    }) as any;
+}
+//#endregion
+
+//#region 队列处理
 /**代办表 用于队列处理等待 */
 static pendingMap:Record<Keyable,AnyFunc[]> = {};
 
@@ -512,6 +673,7 @@ static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
     // 返回Promise，以便调用者可以等待任务完成
     return promise;
 }
+
 /**队列获取目标的代办事件数  
  * @param flag - 队列标签
  */
@@ -519,9 +681,9 @@ static queueLength(flag:Keyable){
     const pd = UtilFunc.pendingMap[flag]
     return pd!=null ? pd.length : 0;
 }
+//#endregion
 
-
-
+//#region symbol化处理工具
 /**创建一个Outcome */
 static outcome<K extends Keyable,V> (key:K,value:V):Outcome<K,V>{
     return {
@@ -530,7 +692,6 @@ static outcome<K extends Keyable,V> (key:K,value:V):Outcome<K,V>{
     }
 }
 
-
 /**处理联合值
  * @param t       - 目标值
  * @param procObj - 所有可能的id组成的处理函数映射 (status, result)=>any
@@ -582,8 +743,6 @@ static matchPartialProc<
     return undefined;
 }
 
-
-
 /**根据典型的成功或失败状态运行函数  
  * @param t - 目标值
  * @param sucessFunc - 成功则运行的函数 (result)=>any
@@ -606,6 +765,7 @@ static sucesProc<T extends Matchable<StatusSymbol>,
     if(t!==None) SLogger.warn(`sucesProc 传入了一个不匹配的值, 将作为None运行: `,t);
     return noneFunc() as any;
 }
+
 /**是失败的 */
 static isFailed<T>
     (tg:T):'E' extends ProperSubsetCheck<symbol,T>? boolean
@@ -655,113 +815,9 @@ static expect<T>(t:T,errLog?:string):Exclude<T,None>{
     if(t===None) UtilFunc.throwError(errLog??"expect验证了一个None值","error");
     return t as Exclude<T,None>;
 }
+//#endregion
 
-/**验证一个变量的类型是否为 T
- * @template T - 验证类型
- * @param t    - 验证目标
- */
-static assertType<T>(t:T):T{return t;}
-/**验证一个变量的类型是否为字面量  
- * 仅限浅层  
- * @template T - 验证类型
- * @param t    - 验证目标
- */
-static assertLiteral<T>(t:Literal<T>):T{return t as T;}
-
-/**深克隆 序列化并反序列化  
- * @template T - JToken类型的泛型
- * @param obj  - 克隆目标
- * @returns 克隆结果
- */
-static deepClone<T extends JToken>(obj: T): T {
-    return JSON.parse(JSON.stringify(obj));
-}
-
-/**是否为安全的数字  
- * 非NaN 非null/undefined  
- * 且是数字  
- * @param num - 所要检测的数字
- * @returns 是否安全
- */
-static isSafeNumber(num: unknown): boolean {
-    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: TemplateStringsArray|string, ...values: any[]): string {
-    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:string,lvl?:LogLevel,opt?:{}):never{
-    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);
-        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] as `${number}:${number}`;
-        return {filePath,lineNumber}
-    }
-    return undefined;
-}
-
-
-private static publicIp?:typeof publicIp;
-
-/**获取当前公网ipv4 */
-static async getPublicIpv4(){
-    if(UtilFunc.publicIp===undefined)
-        UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip') as typeof publicIp;
-    return UtilFunc.publicIp.publicIpv4();
-}
-
+//#region 显式处理错误工具
 /**将传入函数包装为显式处理错误的函数
  * @param func - 待转换函数
  * @returns 转换完成的函数
@@ -794,62 +850,9 @@ static taskEitherize<T extends (...args:any)=>Promise<any>>(func:T) {
         }
     };
 }
+//#endregion
 
-/**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。  
- * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。  
- * 请注意，这个函数使用了eval()，可能会带来安全风险。  
- *
- * @param moduleName - 需要导入的模块的名称。
- * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
- *
- * @example
- * async function main() {
- *   const pip = (await dynamicImport('public-ip')).default;
- *   console.log(await pip.v4());
- * }
- * main();
- *
- * @since Node.js 13.2，Node.js开始支持动态import。
- */
-static async dynamicImport(moduleName:string):Promise<any> {
-    return await eval(`import('${moduleName}')`);
-}
-
-/**缓存池 */
-static cachePool = new WeakMap<Function, Map<string, { result: any, timestamp: number }>>();
-
-/**创建一个带有缓存有效期的memoize函数  
- * 只在传入值均为JToken时有效
- * @param fn     - 需要被memoize的函数
- * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
- * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
- */
-static memoize<T extends (...args:any[])=>any> (fn: T, expiry = Infinity):
-    T extends (...args:infer In)=>any
-        ? AllExtends<In,JToken> extends true ? T : never
-        : never {
-    const cache = UtilFunc.cachePool.get(fn) ?? ivk(()=>{
-        const c = new Map();
-        UtilFunc.cachePool.set(fn, c);
-        return c;
-    });
-
-    return ((...args: Parameters<T>): ReturnType<T> => {
-        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;
-    }) as any;
-}
-
-
-
+//#region 解析srt
 /**将hh:mm:ss,ms格式转换为毫秒 */
 static parseSrtTime(time: string): number {
     const [hours, minutes, seconds] = time.split(':');
@@ -899,5 +902,24 @@ static createSrt(segments: SrtSegment[]): string {
         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<T extends ()=>any>(fn:T): ReturnType<T> {
+    return fn();
+}
+/**一个可供sort使用的从小到大排序的函数 */
+static s2l(a:number,b:number) {
+    return a-b;
+}
+/**一个可供sort使用的从大到小排序的函数 */
+static l2s(a:number,b:number) {
+    return b-a;
+}
+//#endregion
 
 }

package/src/UtilInterfaces.ts

@@ -236,8 +236,10 @@ export type NeedInit = {
     inited: Promise<any>;
 };
 
-/**可选的record */
+/**可选的record PartialRecord */
 export type PRecord<K extends Keyable,V> = Partial<Record<K,V>>;
+/** 可以是Promise MaybePromise*/
+export type MPromise<T> = T | Promise<T>;
 /**任何Record */
 export type AnyRecord = Record<Keyable,any>;
 

package/src/index.ts

@@ -9,6 +9,5 @@ export * from './UtilDecorators';
 export * from './UtilFileTools';
 export * from './UtilLogger';
 export * from './UtilFP';
-export * from './QuickFunction';
-export * from './UtilI18n';
-export * from './LiteFunction';
+export * from './QuickExport';
+export * from './UtilI18n';

package/dist/LiteFunction.d.ts

@@ -1,9 +0,0 @@
-/**立即执行传入的函数
- * @param fn - 需要立即执行的函数。
- * @returns 返回 fn 函数的执行结果。
- */
-export declare function ivk<T extends () => any>(fn: T): ReturnType<T>;
-/**一个可供sort使用的从小到大排序的函数 */
-export declare function s2l(a: number, b: number): number;
-/**一个可供sort使用的从大到小排序的函数 */
-export declare function l2s(a: number, b: number): number;

package/dist/LiteFunction.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ivk = ivk;
-exports.s2l = s2l;
-exports.l2s = l2s;
-/**立即执行传入的函数
- * @param fn - 需要立即执行的函数。
- * @returns 返回 fn 函数的执行结果。
- */
-function ivk(fn) {
-    return fn();
-}
-/**一个可供sort使用的从小到大排序的函数 */
-function s2l(a, b) {
-    return a - b;
-}
-/**一个可供sort使用的从大到小排序的函数 */
-function l2s(a, b) {
-    return b - a;
-}

package/src/LiteFunction.ts

@@ -1,18 +0,0 @@
-
-
-
-/**立即执行传入的函数  
- * @param fn - 需要立即执行的函数。
- * @returns 返回 fn 函数的执行结果。
- */
-export function ivk<T extends ()=>any>(fn:T): ReturnType<T> {
-    return fn();
-}
-/**一个可供sort使用的从小到大排序的函数 */
-export function s2l(a:number,b:number) {
-    return a-b;
-}
-/**一个可供sort使用的从大到小排序的函数 */
-export function l2s(a:number,b:number) {
-    return b-a;
-}