@zwa73/utils 1.0.193 → 1.0.195

package/dist/UtilFunctions.js

@@ -44,12 +44,12 @@ const UtilDecorators_1 = require("./UtilDecorators");
 const path_1 = __importDefault(require("path"));
 const UtilFileTools_1 = require("./UtilFileTools");
 const util_1 = require("util");
-const LiteFunction_1 = require("./LiteFunction");
 const HashMethodList = ["md5", "sha1", "sha256", "sha512", "sha3", "blake2", "blake3"];
 /**永不完成的Promise单例 */
 const NeverResolvedPromise = new Promise(() => { });
 /**常用函数 */
 class UtilFunc {
+    //#region 杂项
     /**获取当前时间戳
      * @returns 时间戳
      */
@@ -104,8 +104,8 @@ class UtilFunc {
         return crypto.createHash(method).update(str).digest('hex');
     }
     static async sleep(timeMs, result) {
-        return new Promise(function (resolve, rejecte) {
-            let timer = setTimeout(function () {
+        return new Promise((resolve, rejecte) => {
+            const timer = setTimeout(() => {
                 resolve(result);
             }, timeMs);
         });
@@ -386,6 +386,150 @@ class UtilFunc {
         return JSON.stringify(token, compressReplacer, space)
             .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();
+    }
+    /**动态导入模块的函数。这个函数是为了在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) {
+        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 = {};
     /**队列处理
@@ -448,6 +592,8 @@ class UtilFunc {
         const pd = UtilFunc.pendingMap[flag];
         return pd != null ? pd.length : 0;
     }
+    //#endregion
+    //#region symbol化处理工具
     /**创建一个Outcome */
     static outcome(key, value) {
         return {
@@ -545,104 +691,8 @@ class UtilFunc {
             UtilFunc.throwError(errLog ?? "expect验证了一个None值", "error");
         return t;
     }
-    /**验证一个变量的类型是否为 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();
-    }
+    //#endregion
+    //#region 显式处理错误工具
     /**将传入函数包装为显式处理错误的函数
      * @param func - 待转换函数
      * @returns 转换完成的函数
@@ -677,50 +727,8 @@ class UtilFunc {
             }
         };
     }
-    /**动态导入模块的函数。这个函数是为了在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) {
-        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) ?? (0, LiteFunction_1.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 解析srt
     /**将hh:mm:ss,ms格式转换为毫秒 */
     static parseSrtTime(time) {
         const [hours, minutes, seconds] = time.split(':');
@@ -764,6 +772,23 @@ class UtilFunc {
             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([

package/dist/UtilInterfaces.d.ts

@@ -154,8 +154,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/dist/index.d.ts

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

package/dist/index.js

@@ -25,6 +25,5 @@ __exportStar(require("./UtilDecorators"), exports);
 __exportStar(require("./UtilFileTools"), exports);
 __exportStar(require("./UtilLogger"), exports);
 __exportStar(require("./UtilFP"), exports);
-__exportStar(require("./QuickFunction"), exports);
+__exportStar(require("./QuickExport"), exports);
 __exportStar(require("./UtilI18n"), exports);
-__exportStar(require("./LiteFunction"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.193",
+	"version": "1.0.195",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {

package/src/{QuickFunction.ts → QuickExport.ts}

@@ -24,6 +24,7 @@ export const {
     eitherize,
     taskEitherize,
     memoize,
+    ivk,l2s,s2l,
 } = UtilFunc;
 
 export const {

package/src/UtilClass.ts

@@ -1,5 +1,5 @@
-import { matchProc } from "./QuickFunction";
-import { Keyable, Literal } from "./UtilInterfaces";
+import { matchProc } from "./QuickExport";
+import { Keyable, Literal, MPromise } from "./UtilInterfaces";
 import Handlebars from 'handlebars';
 import { SLogger } from "./UtilLogger";
 
@@ -38,7 +38,7 @@ export class Piper<Arg, Result = Arg> {
 }
 
 
-type StreamOperation<T, U> = (item: T)=>Promise<U>|U;
+type StreamOperation<T, U> = (item: T)=>MPromise<U>;
 /**并行流 */
 export class Stream<T> implements Iterable<T>{
     /**并发数*/
@@ -52,13 +52,16 @@ export class Stream<T> implements Iterable<T>{
         else this._list = new Array(...base);
         this._concurrent = concurrent;
     }
-    /**从arraylike创建流 */
-    static from<T>(args:Parameters<typeof Array.from<T>>[0],concurrent:number=1){
-        return new Stream<T>(Array.from(args),concurrent);
+    /**从arraylike创建流
+     * @param args - arraylike
+     * @param concurrent - 并发数 默认 1
+     */
+    static from<T>(args:ArrayLike<T>,concurrent:number=1){
+        return new Stream(Array.from(args),concurrent);
     }
     /**从数组创建流 */
     static of<T>(...args:T[]){
-        return new Stream<T>(args);
+        return new Stream(args);
     }
     /**设置并发数 */
     concurrent(count: number): Stream<T> {

package/src/UtilFP.ts

@@ -1,4 +1,4 @@
-import { isFailed, likeNone } from "./QuickFunction";
+import { isFailed, likeNone } from "./QuickExport";
 import { AnyRecord, Keyable, Literal, Matchable, MatchableFlag, ProperSubset, ProperSubsetCheck } from "./UtilInterfaces";
 import { Failed, FailedLike, None } from "./UtilSymbol";
 

package/src/UtilFfmpegTools.ts

@@ -4,7 +4,7 @@ import path from "pathe";
 import * as fs from "fs";
 import { SLogger } from "@/src/UtilLogger";
 import { Stream } from "./UtilClass";
-import { throwError } from "./QuickFunction";
+import { throwError } from "./QuickExport";
 
 /**输入输出路径映射
  * 输入路径:输入路径