npm - @zwa73/utils - Versions diffs - 1.0.34 → 1.0.35 - Mend

@zwa73/utils 1.0.34 → 1.0.35

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/dist/UtilCodecs.d.ts CHANGED Viewed

@@ -1,40 +1,43 @@
-/**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
- * @param {string} str - 要转换的字符串
- * @returns {string} 转换后的字符串
- */
-export declare function decodeHtmlEntities(str: string): string;
-/**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
- * @param {string} str - 要转换的字符串
- * @returns {string} 转换后的字符串
- */
-export declare function encodeHtmlEntities(str: string): string;
-/**token长度计算器 Turbo模型
- * @param {string} str = 所要计算的消息
- * @returns {number} 整数长度结果
- */
-export declare function tokenNumTurbo(str: string): number;
-/**token长度计算器 Davinci模型
- * @param {string} str = 所要计算的消息
- * @returns {number} 整数长度结果
- */
-export declare function tokenNumDavinci(str: string): number;
-/**token编码 Turbo模型
- * @param {string} str = 所要计算的消息
- * @returns {Array<number>} Token数组
- */
-export declare function encodeTokenTurbo(str: string): Uint32Array;
-/**token编码 Davinci模型
- * @param {string} str = 所要计算的消息
- * @returns {Array<number>} Token数组
- */
-export declare function encodeTokenDavinci(str: string): Uint32Array;
-/**token解码 Turbo模型
- * @param {Array<number>} arr = Token数组
- * @returns {string} 消息字符串
- */
-export declare function decodeTokenTurbo(arr: Uint32Array): string;
-/**token解码 Davinci模型
- * @param {Array<number>} arr = Token数组
- * @returns {string} 消息字符串
- */
-export declare function decodeTokenDavinci(arr: Uint32Array): string;
+/**编码/解码器 */
+export declare namespace UtilCodec {
+    /**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
+     * @param {string} str - 要转换的字符串
+     * @returns {string} 转换后的字符串
+     */
+    function decodeHtmlEntities(str: string): string;
+    /**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
+     * @param {string} str - 要转换的字符串
+     * @returns {string} 转换后的字符串
+     */
+    function encodeHtmlEntities(str: string): string;
+    /**token长度计算器 Turbo模型
+     * @param {string} str = 所要计算的消息
+     * @returns {number} 整数长度结果
+     */
+    function tokenNumTurbo(str: string): number;
+    /**token长度计算器 Davinci模型
+     * @param {string} str = 所要计算的消息
+     * @returns {number} 整数长度结果
+     */
+    function tokenNumDavinci(str: string): number;
+    /**token编码 Turbo模型
+     * @param {string} str = 所要计算的消息
+     * @returns {Array<number>} Token数组
+     */
+    function encodeTokenTurbo(str: string): Uint32Array;
+    /**token编码 Davinci模型
+     * @param {string} str = 所要计算的消息
+     * @returns {Array<number>} Token数组
+     */
+    function encodeTokenDavinci(str: string): Uint32Array;
+    /**token解码 Turbo模型
+     * @param {Array<number>} arr = Token数组
+     * @returns {string} 消息字符串
+     */
+    function decodeTokenTurbo(arr: Uint32Array): string;
+    /**token解码 Davinci模型
+     * @param {Array<number>} arr = Token数组
+     * @returns {string} 消息字符串
+     */
+    function decodeTokenDavinci(arr: Uint32Array): string;
+}

package/dist/UtilCodecs.js CHANGED Viewed

@@ -1,110 +1,114 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeTokenDavinci = exports.decodeTokenTurbo = exports.encodeTokenDavinci = exports.encodeTokenTurbo = exports.tokenNumDavinci = exports.tokenNumTurbo = exports.encodeHtmlEntities = exports.decodeHtmlEntities = void 0;
+exports.UtilCodec = void 0;
 const he = require("html-entities");
 const tiktoken_1 = require("tiktoken");
-let encoderTurbo = null;
-let encoderDavinci = null;
-const textDecoder = new TextDecoder();
-// 定义一个对象，存储常见的HTML实体和对应的字符
-let htmlEntities = {
-    "&lt;": "<",
-    "&gt;": ">",
-    "&amp;": "&",
-    "&quot;": "\"",
-    "&#39;": "'",
-    "&#91;": "[",
-    "&#93;": "]"
-};
-/**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
- * @param {string} str - 要转换的字符串
- * @returns {string} 转换后的字符串
- */
-function decodeHtmlEntities(str) {
-    //for(let code in htmlEntities){
-    //	let cha = htmlEntities[code]
-    //	str = str.replaceAll(code, cha);
-    //}
-    //return str
-    return he.decode(str);
-}
-exports.decodeHtmlEntities = decodeHtmlEntities;
-/**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
- * @param {string} str - 要转换的字符串
- * @returns {string} 转换后的字符串
- */
-function encodeHtmlEntities(str) {
-    //for(let code in htmlEntities){
-    //	let cha = htmlEntities[code]
-    //	str = str.replaceAll(cha, code);
-    //}
-    //return str
-    return he.encode(str);
-}
-exports.encodeHtmlEntities = encodeHtmlEntities;
-//token长度计算器
-//cl100k_base	ChatGPT models, text-embedding-ada-002
-//p50k_base	Code models, text-davinci-002, text-davinci-003
-//r50k_base (or gpt2)	GPT-3 models like davinci
-//避免在nextjs调用时出错
-function initTikTokenEncoder() {
-    if (encoderTurbo != null && encoderDavinci != null)
-        return;
-    encoderTurbo = (0, tiktoken_1.get_encoding)("cl100k_base");
-    encoderDavinci = (0, tiktoken_1.get_encoding)("p50k_base");
-}
-/**token长度计算器 Turbo模型
- * @param {string} str = 所要计算的消息
- * @returns {number} 整数长度结果
- */
-function tokenNumTurbo(str) {
-    initTikTokenEncoder();
-    //return encoder.encode(str).length
-    return encoderTurbo?.encode(str).length;
-}
-exports.tokenNumTurbo = tokenNumTurbo;
-/**token长度计算器 Davinci模型
- * @param {string} str = 所要计算的消息
- * @returns {number} 整数长度结果
- */
-function tokenNumDavinci(str) {
-    initTikTokenEncoder();
-    return encoderDavinci?.encode(str).length;
-}
-exports.tokenNumDavinci = tokenNumDavinci;
-/**token编码 Turbo模型
- * @param {string} str = 所要计算的消息
- * @returns {Array<number>} Token数组
- */
-function encodeTokenTurbo(str) {
-    initTikTokenEncoder();
-    return encoderTurbo?.encode(str);
-}
-exports.encodeTokenTurbo = encodeTokenTurbo;
-/**token编码 Davinci模型
- * @param {string} str = 所要计算的消息
- * @returns {Array<number>} Token数组
- */
-function encodeTokenDavinci(str) {
-    initTikTokenEncoder();
-    return encoderDavinci?.encode(str);
-}
-exports.encodeTokenDavinci = encodeTokenDavinci;
-/**token解码 Turbo模型
- * @param {Array<number>} arr = Token数组
- * @returns {string} 消息字符串
- */
-function decodeTokenTurbo(arr) {
-    initTikTokenEncoder();
-    return textDecoder.decode(encoderTurbo?.decode(arr));
-}
-exports.decodeTokenTurbo = decodeTokenTurbo;
-/**token解码 Davinci模型
- * @param {Array<number>} arr = Token数组
- * @returns {string} 消息字符串
- */
-function decodeTokenDavinci(arr) {
-    initTikTokenEncoder();
-    return textDecoder.decode(encoderDavinci?.decode(arr));
-}
-exports.decodeTokenDavinci = decodeTokenDavinci;
+/**编码/解码器 */
+var UtilCodec;
+(function (UtilCodec) {
+    let encoderTurbo = null;
+    let encoderDavinci = null;
+    const textDecoder = new TextDecoder();
+    // 定义一个对象，存储常见的HTML实体和对应的字符
+    let htmlEntities = {
+        "&lt;": "<",
+        "&gt;": ">",
+        "&amp;": "&",
+        "&quot;": "\"",
+        "&#39;": "'",
+        "&#91;": "[",
+        "&#93;": "]"
+    };
+    /**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
+     * @param {string} str - 要转换的字符串
+     * @returns {string} 转换后的字符串
+     */
+    function decodeHtmlEntities(str) {
+        //for(let code in htmlEntities){
+        //	let cha = htmlEntities[code]
+        //	str = str.replaceAll(code, cha);
+        //}
+        //return str
+        return he.decode(str);
+    }
+    UtilCodec.decodeHtmlEntities = decodeHtmlEntities;
+    /**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
+     * @param {string} str - 要转换的字符串
+     * @returns {string} 转换后的字符串
+     */
+    function encodeHtmlEntities(str) {
+        //for(let code in htmlEntities){
+        //	let cha = htmlEntities[code]
+        //	str = str.replaceAll(cha, code);
+        //}
+        //return str
+        return he.encode(str);
+    }
+    UtilCodec.encodeHtmlEntities = encodeHtmlEntities;
+    //token长度计算器
+    //cl100k_base	ChatGPT models, text-embedding-ada-002
+    //p50k_base	Code models, text-davinci-002, text-davinci-003
+    //r50k_base (or gpt2)	GPT-3 models like davinci
+    //避免在nextjs调用时出错
+    function initTikTokenEncoder() {
+        if (encoderTurbo != null && encoderDavinci != null)
+            return;
+        encoderTurbo = (0, tiktoken_1.get_encoding)("cl100k_base");
+        encoderDavinci = (0, tiktoken_1.get_encoding)("p50k_base");
+    }
+    /**token长度计算器 Turbo模型
+     * @param {string} str = 所要计算的消息
+     * @returns {number} 整数长度结果
+     */
+    function tokenNumTurbo(str) {
+        initTikTokenEncoder();
+        //return encoder.encode(str).length
+        return encoderTurbo?.encode(str).length;
+    }
+    UtilCodec.tokenNumTurbo = tokenNumTurbo;
+    /**token长度计算器 Davinci模型
+     * @param {string} str = 所要计算的消息
+     * @returns {number} 整数长度结果
+     */
+    function tokenNumDavinci(str) {
+        initTikTokenEncoder();
+        return encoderDavinci?.encode(str).length;
+    }
+    UtilCodec.tokenNumDavinci = tokenNumDavinci;
+    /**token编码 Turbo模型
+     * @param {string} str = 所要计算的消息
+     * @returns {Array<number>} Token数组
+     */
+    function encodeTokenTurbo(str) {
+        initTikTokenEncoder();
+        return encoderTurbo?.encode(str);
+    }
+    UtilCodec.encodeTokenTurbo = encodeTokenTurbo;
+    /**token编码 Davinci模型
+     * @param {string} str = 所要计算的消息
+     * @returns {Array<number>} Token数组
+     */
+    function encodeTokenDavinci(str) {
+        initTikTokenEncoder();
+        return encoderDavinci?.encode(str);
+    }
+    UtilCodec.encodeTokenDavinci = encodeTokenDavinci;
+    /**token解码 Turbo模型
+     * @param {Array<number>} arr = Token数组
+     * @returns {string} 消息字符串
+     */
+    function decodeTokenTurbo(arr) {
+        initTikTokenEncoder();
+        return textDecoder.decode(encoderTurbo?.decode(arr));
+    }
+    UtilCodec.decodeTokenTurbo = decodeTokenTurbo;
+    /**token解码 Davinci模型
+     * @param {Array<number>} arr = Token数组
+     * @returns {string} 消息字符串
+     */
+    function decodeTokenDavinci(arr) {
+        initTikTokenEncoder();
+        return textDecoder.decode(encoderDavinci?.decode(arr));
+    }
+    UtilCodec.decodeTokenDavinci = decodeTokenDavinci;
+})(UtilCodec = exports.UtilCodec || (exports.UtilCodec = {}));

package/dist/UtilCom.d.ts CHANGED Viewed

@@ -1,19 +1,22 @@
 import { JObject } from "./UtilInterfaces";
-/**发送一个POST请求并接受数据
- * Object ()
- * @async
- * @param {JObject} json 	   - 数据对象
- * @param {Object} options     - 参数对象
- * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
- * @returns {Promise<Object|null>} 结果 null 为未能成功接收
- */
-export declare function shttpsPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
-/**发送一个POST请求并接受数据
- * Object ()
- * @async
- * @param {JObject} json 	   - 数据对象
- * @param {Object} options     - 参数对象
- * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
- * @returns {Promise<Object|null>} 结果 null 为未能成功接收
- */
-export declare function shttpPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
+/**网络工具 */
+export declare namespace UtilCom {
+    /**发送一个POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	   - 数据对象
+     * @param {Object} options     - 参数对象
+     * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
+     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     */
+    function shttpsPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
+    /**发送一个POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	   - 数据对象
+     * @param {Object} options     - 参数对象
+     * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
+     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     */
+    function shttpPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
+}

package/dist/UtilCom.js CHANGED Viewed

@@ -1,97 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shttpPost = exports.shttpsPost = void 0;
+exports.UtilCom = void 0;
 const UtilInterfaces_1 = require("./UtilInterfaces");
 const https = require("https");
 const http = require("http");
 const UtilLogger_1 = require("./UtilLogger");
-function sPost(type, json, options, timeLimit = -1) {
-    //转换为毫秒
-    const hasTimeLimit = (timeLimit >= 10);
-    if (hasTimeLimit)
-        timeLimit *= 1000;
-    const jsonStr = (0, UtilInterfaces_1.stringifyJToken)(json);
-    const funcName = "s" + type + "Psot";
-    return new Promise((resolve, rejecte) => {
-        const resFunc = (res) => {
-            try {
-                //请求超时
-                if (hasTimeLimit) {
-                    res.setTimeout(timeLimit, () => {
-                        //res.abort();
-                        throw funcName + " 接收反馈超时: " + timeLimit + " ms";
+/**网络工具 */
+var UtilCom;
+(function (UtilCom) {
+    function sPost(type, json, options, timeLimit = -1) {
+        //转换为毫秒
+        const hasTimeLimit = (timeLimit >= 10);
+        if (hasTimeLimit)
+            timeLimit *= 1000;
+        const jsonStr = (0, UtilInterfaces_1.stringifyJToken)(json);
+        const funcName = "s" + type + "Psot";
+        return new Promise((resolve, rejecte) => {
+            const resFunc = (res) => {
+                try {
+                    //请求超时
+                    if (hasTimeLimit) {
+                        res.setTimeout(timeLimit, () => {
+                            //res.abort();
+                            throw funcName + " 接收反馈超时: " + timeLimit + " ms";
+                        });
+                    }
+                    let resdata = "";
+                    res.setEncoding('utf8');
+                    res.on('data', (chunk) => resdata += chunk);
+                    res.on('error', (e) => {
+                        throw funcName + " 接收反馈错误:" + e;
+                    });
+                    res.on('end', () => {
+                        if (resdata == "")
+                            throw funcName + " 接收反馈错误: resdata 为空";
+                        try {
+                            let obj = JSON.parse(resdata);
+                            UtilLogger_1.SLogger.http(funcName + " 接受信息:", obj);
+                            resolve(obj);
+                            return;
+                        }
+                        catch (e) {
+                            throw funcName + " 接收反馈错误:" + e + "\n原始字符串:" + resdata;
+                        }
                     });
                 }
-                let resdata = "";
-                res.setEncoding('utf8');
-                res.on('data', (chunk) => resdata += chunk);
-                res.on('error', (e) => {
-                    throw funcName + " 接收反馈错误:" + e;
-                });
-                res.on('end', () => {
-                    if (resdata == "")
-                        throw funcName + " 接收反馈错误: resdata 为空";
-                    try {
-                        let obj = JSON.parse(resdata);
-                        UtilLogger_1.SLogger.http(funcName + " 接受信息:", obj);
-                        resolve(obj);
-                        return;
-                    }
-                    catch (e) {
-                        throw funcName + " 接收反馈错误:" + e + "\n原始字符串:" + resdata;
-                    }
+                catch (err) {
+                    if (typeof err != "string")
+                        throw err;
+                    UtilLogger_1.SLogger.warn(err);
+                    resolve(null);
+                    return;
+                }
+            };
+            //路由 http/https
+            let req = null;
+            if (type === "https")
+                req = https.request(options, resFunc);
+            else if (type === "http")
+                req = http.request(options, resFunc);
+            //请求超时
+            if (hasTimeLimit) {
+                req.setTimeout(timeLimit, () => {
+                    UtilLogger_1.SLogger.warn(funcName + " 发送请求超时: " + timeLimit + " ms");
+                    req.destroy();
                 });
             }
-            catch (err) {
-                if (typeof err != "string")
-                    throw err;
-                UtilLogger_1.SLogger.warn(err);
+            req.on('error', (e) => {
+                UtilLogger_1.SLogger.warn(funcName + " 发送请求错误:" + e);
                 resolve(null);
-                return;
-            }
-        };
-        //路由 http/https
-        let req = null;
-        if (type === "https")
-            req = https.request(options, resFunc);
-        else if (type === "http")
-            req = http.request(options, resFunc);
-        //请求超时
-        if (hasTimeLimit) {
-            req.setTimeout(timeLimit, () => {
-                UtilLogger_1.SLogger.warn(funcName + " 发送请求超时: " + timeLimit + " ms");
-                req.destroy();
             });
-        }
-        req.on('error', (e) => {
-            UtilLogger_1.SLogger.warn(funcName + " 发送请求错误:" + e);
-            resolve(null);
+            req.write(jsonStr);
+            req.end();
         });
-        req.write(jsonStr);
-        req.end();
-    });
-}
-/**发送一个POST请求并接受数据
- * Object ()
- * @async
- * @param {JObject} json 	   - 数据对象
- * @param {Object} options     - 参数对象
- * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
- * @returns {Promise<Object|null>} 结果 null 为未能成功接收
- */
-function shttpsPost(json, options, timeLimit = -1) {
-    return sPost("https", json, options, timeLimit);
-}
-exports.shttpsPost = shttpsPost;
-/**发送一个POST请求并接受数据
- * Object ()
- * @async
- * @param {JObject} json 	   - 数据对象
- * @param {Object} options     - 参数对象
- * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
- * @returns {Promise<Object|null>} 结果 null 为未能成功接收
- */
-function shttpPost(json, options, timeLimit = -1) {
-    return sPost("http", json, options, timeLimit);
-}
-exports.shttpPost = shttpPost;
+    }
+    /**发送一个POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	   - 数据对象
+     * @param {Object} options     - 参数对象
+     * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
+     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     */
+    function shttpsPost(json, options, timeLimit = -1) {
+        return sPost("https", json, options, timeLimit);
+    }
+    UtilCom.shttpsPost = shttpsPost;
+    /**发送一个POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	   - 数据对象
+     * @param {Object} options     - 参数对象
+     * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
+     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     */
+    function shttpPost(json, options, timeLimit = -1) {
+        return sPost("http", json, options, timeLimit);
+    }
+    UtilCom.shttpPost = shttpPost;
+})(UtilCom = exports.UtilCom || (exports.UtilCom = {}));

package/dist/UtilFileTools.d.ts CHANGED Viewed

@@ -1,79 +1,82 @@
 import { JObject, JToken } from "./UtilInterfaces";
-/**验证路径 文件或文件夹 是否存在 异步
- * @async
- * @param {string} filePath - 待验证的路径
- * @returns {Promise<boolean>} - 是否存在
- */
-export declare function pathExists(filePath: string): Promise<boolean>;
-/**验证路径 文件或文件夹 是否存在 同步
- * @param {string} filePath - 待验证的路径
- * @returns {boolean} - 是否存在
- */
-export declare function pathExistsSync(filePath: string): boolean;
-/**路径不存在时创建路径 以path.sep结尾时创建文件夹 异步
- * @async
- * @param {string} filePath - 待创建的路径
- * @param {boolean} isDir   - 强制创建一个文件夹
- * @returns {Promise<boolean>} - 是否成功创建
- */
-export declare function createPath(filePath: string, isDir?: boolean): Promise<boolean>;
-/**路径不存在时创建路径 以path.sep结尾时创建文件夹 同步
- * @param {string} filePath - 待创建的路径
- * @param {boolean} isDir   - 强制验证一个文件夹
- * @returns {boolean} - 是否成功创建
- */
-export declare function createPathSync(filePath: string, isDir?: boolean): boolean;
-/**确保路径存在 不存在时创建 异步
- * @async
- * @param {string} filePath - 待验证的路径
- * @param {boolean} isDir   - 强制验证一个文件夹
- * @returns {Promise<boolean>} - 是否成功执行 创建或已存在
- */
-export declare function ensurePathExists(filePath: string, isDir?: boolean): Promise<boolean>;
-/**确保路径存在 不存在时创建 同步
- * @param {string} filePath - 待验证的路径
- * @returns {boolean} - 是否成功执行 创建或已存在
- */
-export declare function ensurePathExistsSync(filePath: string, isDir?: boolean): boolean;
-/**加载json文件 同步
- * Object (string)
- * @param {string} filePath - 文件路径
- * @returns {JObject}       - 加载完成的对象或空{}
- */
-export declare function loadJSONFileSync(filePath: string): JObject;
-/**加载json文件 同步
- * Object (string)
- * @param {string} filePath - 文件路径
- * @param {T}      def      - 默认值
- * @returns {T}             - 加载完成的对象或默认值
- */
-export declare function loadJSONFileSync<T extends JToken>(filePath: string, def: T): T;
-/**加载json文件 异步
- * Object (string)
- * @async
- * @param {string} filePath - 文件路径
- * @returns {Promise<JObject>} - 加载完成的对象或空{}
- */
-export declare function loadJSONFile(filePath: string): Promise<JObject>;
-/**加载json文件 异步
- * Object (string)
- * @async
- * @param {string} filePath - 文件路径
- * @param {T}      T        - 默认值
- * @returns {Promise<T>} - 加载完成的对象或默认值
- */
-export declare function loadJSONFile<T extends JToken>(filePath: string, def: T): Promise<T>;
-/**写入JSON文件
- * void (string,Object)
- * @async
- * @param {string} filePath - 文件路径
- * @param {JToken} token 	    - 所要写入的JToken
- * @returns {Promise<void>}
- */
-export declare function writeJSONFile(filePath: string, token: JToken): Promise<void>;
-/**搜索路径符合正则表达式的文件
- * @param folder - 文件夹路径
- * @param traitRegex - 正则表达式
- * @returns {Record<string, string>} 文件名与路径的映射
- */
-export declare function fileSearch(folder: string, traitRegex: string): Record<string, string>;
+/**文件工具 */
+export declare namespace UtilFT {
+    /**验证路径 文件或文件夹 是否存在 异步
+     * @async
+     * @param {string} filePath - 待验证的路径
+     * @returns {Promise<boolean>} - 是否存在
+     */
+    function pathExists(filePath: string): Promise<boolean>;
+    /**验证路径 文件或文件夹 是否存在 同步
+     * @param {string} filePath - 待验证的路径
+     * @returns {boolean} - 是否存在
+     */
+    function pathExistsSync(filePath: string): boolean;
+    /**路径不存在时创建路径 以path.sep结尾时创建文件夹 异步
+     * @async
+     * @param {string} filePath - 待创建的路径
+     * @param {boolean} isDir   - 强制创建一个文件夹
+     * @returns {Promise<boolean>} - 是否成功创建
+     */
+    function createPath(filePath: string, isDir?: boolean): Promise<boolean>;
+    /**路径不存在时创建路径 以path.sep结尾时创建文件夹 同步
+     * @param {string} filePath - 待创建的路径
+     * @param {boolean} isDir   - 强制验证一个文件夹
+     * @returns {boolean} - 是否成功创建
+     */
+    function createPathSync(filePath: string, isDir?: boolean): boolean;
+    /**确保路径存在 不存在时创建 异步
+     * @async
+     * @param {string} filePath - 待验证的路径
+     * @param {boolean} isDir   - 强制验证一个文件夹
+     * @returns {Promise<boolean>} - 是否成功执行 创建或已存在
+     */
+    function ensurePathExists(filePath: string, isDir?: boolean): Promise<boolean>;
+    /**确保路径存在 不存在时创建 同步
+     * @param {string} filePath - 待验证的路径
+     * @returns {boolean} - 是否成功执行 创建或已存在
+     */
+    function ensurePathExistsSync(filePath: string, isDir?: boolean): boolean;
+    /**加载json文件 同步
+     * Object (string)
+     * @param {string} filePath - 文件路径
+     * @returns {JObject}       - 加载完成的对象或空{}
+     */
+    function loadJSONFileSync(filePath: string): JObject;
+    /**加载json文件 同步
+     * Object (string)
+     * @param {string} filePath - 文件路径
+     * @param {T}      def      - 默认值
+     * @returns {T}             - 加载完成的对象或默认值
+     */
+    function loadJSONFileSync<T extends JToken>(filePath: string, def: T): T;
+    /**加载json文件 异步
+     * Object (string)
+     * @async
+     * @param {string} filePath - 文件路径
+     * @returns {Promise<JObject>} - 加载完成的对象或空{}
+     */
+    function loadJSONFile(filePath: string): Promise<JObject>;
+    /**加载json文件 异步
+     * Object (string)
+     * @async
+     * @param {string} filePath - 文件路径
+     * @param {T}      T        - 默认值
+     * @returns {Promise<T>} - 加载完成的对象或默认值
+     */
+    function loadJSONFile<T extends JToken>(filePath: string, def: T): Promise<T>;
+    /**写入JSON文件
+     * void (string,Object)
+     * @async
+     * @param {string} filePath - 文件路径
+     * @param {JToken} token 	    - 所要写入的JToken
+     * @returns {Promise<void>}
+     */
+    function writeJSONFile(filePath: string, token: JToken): Promise<void>;
+    /**搜索路径符合正则表达式的文件
+     * @param folder - 文件夹路径
+     * @param traitRegex - 正则表达式
+     * @returns {Record<string, string>} 文件名与路径的映射
+     */
+    function fileSearch(folder: string, traitRegex: string): Record<string, string>;
+}

package/dist/UtilFileTools.js CHANGED Viewed

@@ -1,188 +1,192 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileSearch = exports.writeJSONFile = exports.loadJSONFile = exports.loadJSONFileSync = exports.ensurePathExistsSync = exports.ensurePathExists = exports.createPathSync = exports.createPath = exports.pathExistsSync = exports.pathExists = void 0;
+exports.UtilFT = void 0;
 const fs = require("fs");
 const path = require("path");
 const UtilInterfaces_1 = require("./UtilInterfaces");
 const UtilLogger_1 = require("./UtilLogger");
-/**验证路径 文件或文件夹 是否存在 异步
- * @async
- * @param {string} filePath - 待验证的路径
- * @returns {Promise<boolean>} - 是否存在
- */
-async function pathExists(filePath) {
-    try {
-        const stats = await fs.promises.stat(filePath);
-        await fs.promises.access(filePath);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-}
-exports.pathExists = pathExists;
-/**验证路径 文件或文件夹 是否存在 同步
- * @param {string} filePath - 待验证的路径
- * @returns {boolean} - 是否存在
- */
-function pathExistsSync(filePath) {
-    try {
-        fs.accessSync(filePath);
-        return true;
-    }
-    catch (e) {
-        return false;
+/**文件工具 */
+var UtilFT;
+(function (UtilFT) {
+    /**验证路径 文件或文件夹 是否存在 异步
+     * @async
+     * @param {string} filePath - 待验证的路径
+     * @returns {Promise<boolean>} - 是否存在
+     */
+    async function pathExists(filePath) {
+        try {
+            const stats = await fs.promises.stat(filePath);
+            await fs.promises.access(filePath);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
     }
-}
-exports.pathExistsSync = pathExistsSync;
-/**路径不存在时创建路径 以path.sep结尾时创建文件夹 异步
- * @async
- * @param {string} filePath - 待创建的路径
- * @param {boolean} isDir   - 强制创建一个文件夹
- * @returns {Promise<boolean>} - 是否成功创建
- */
-async function createPath(filePath, isDir) {
-    if (isDir == true)
-        filePath = path.join(filePath, path.sep);
-    try {
-        if (filePath.endsWith(path.sep)) {
-            await fs.promises.mkdir(filePath, { recursive: true });
+    UtilFT.pathExists = pathExists;
+    /**验证路径 文件或文件夹 是否存在 同步
+     * @param {string} filePath - 待验证的路径
+     * @returns {boolean} - 是否存在
+     */
+    function pathExistsSync(filePath) {
+        try {
+            fs.accessSync(filePath);
             return true;
         }
-        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-        await fs.promises.open(filePath, 'w');
-        return true;
+        catch (e) {
+            return false;
+        }
     }
-    catch (e) {
-        UtilLogger_1.SLogger.error("createPath 错误", e);
-        return false;
+    UtilFT.pathExistsSync = pathExistsSync;
+    /**路径不存在时创建路径 以path.sep结尾时创建文件夹 异步
+     * @async
+     * @param {string} filePath - 待创建的路径
+     * @param {boolean} isDir   - 强制创建一个文件夹
+     * @returns {Promise<boolean>} - 是否成功创建
+     */
+    async function createPath(filePath, isDir) {
+        if (isDir == true)
+            filePath = path.join(filePath, path.sep);
+        try {
+            if (filePath.endsWith(path.sep)) {
+                await fs.promises.mkdir(filePath, { recursive: true });
+                return true;
+            }
+            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.promises.open(filePath, 'w');
+            return true;
+        }
+        catch (e) {
+            UtilLogger_1.SLogger.error("createPath 错误", e);
+            return false;
+        }
     }
-}
-exports.createPath = createPath;
-/**路径不存在时创建路径 以path.sep结尾时创建文件夹 同步
- * @param {string} filePath - 待创建的路径
- * @param {boolean} isDir   - 强制验证一个文件夹
- * @returns {boolean} - 是否成功创建
- */
-function createPathSync(filePath, isDir) {
-    if (isDir == true)
-        filePath = path.join(filePath, path.sep);
-    try {
-        if (filePath.endsWith(path.sep)) {
-            fs.mkdirSync(filePath, { recursive: true });
+    UtilFT.createPath = createPath;
+    /**路径不存在时创建路径 以path.sep结尾时创建文件夹 同步
+     * @param {string} filePath - 待创建的路径
+     * @param {boolean} isDir   - 强制验证一个文件夹
+     * @returns {boolean} - 是否成功创建
+     */
+    function createPathSync(filePath, isDir) {
+        if (isDir == true)
+            filePath = path.join(filePath, path.sep);
+        try {
+            if (filePath.endsWith(path.sep)) {
+                fs.mkdirSync(filePath, { recursive: true });
+                return true;
+            }
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.openSync(filePath, 'w');
             return true;
         }
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.openSync(filePath, 'w');
-        return true;
+        catch (e) {
+            UtilLogger_1.SLogger.error("createPathSync 错误", e);
+            return false;
+        }
     }
-    catch (e) {
-        UtilLogger_1.SLogger.error("createPathSync 错误", e);
-        return false;
+    UtilFT.createPathSync = createPathSync;
+    /**确保路径存在 不存在时创建 异步
+     * @async
+     * @param {string} filePath - 待验证的路径
+     * @param {boolean} isDir   - 强制验证一个文件夹
+     * @returns {Promise<boolean>} - 是否成功执行 创建或已存在
+     */
+    async function ensurePathExists(filePath, isDir) {
+        if (await pathExists(filePath))
+            return true;
+        return await createPath(filePath, isDir);
     }
-}
-exports.createPathSync = createPathSync;
-/**确保路径存在 不存在时创建 异步
- * @async
- * @param {string} filePath - 待验证的路径
- * @param {boolean} isDir   - 强制验证一个文件夹
- * @returns {Promise<boolean>} - 是否成功执行 创建或已存在
- */
-async function ensurePathExists(filePath, isDir) {
-    if (await pathExists(filePath))
-        return true;
-    return await createPath(filePath, isDir);
-}
-exports.ensurePathExists = ensurePathExists;
-/**确保路径存在 不存在时创建 同步
- * @param {string} filePath - 待验证的路径
- * @returns {boolean} - 是否成功执行 创建或已存在
- */
-function ensurePathExistsSync(filePath, isDir) {
-    if (pathExistsSync(filePath))
-        return true;
-    return createPathSync(filePath, isDir);
-}
-exports.ensurePathExistsSync = ensurePathExistsSync;
-function loadJSONFileSync(filePath, def) {
-    if (path.extname(filePath) !== '.json')
-        filePath += '.json';
-    let str = "";
-    // 判断文件路径是否存在
-    if (pathExistsSync(filePath))
-        str = fs.readFileSync(filePath, "utf-8");
-    // 如果不存在则返回默认值
-    if (str == "" || str == null) {
-        if (def !== undefined)
-            return def;
-        return {};
+    UtilFT.ensurePathExists = ensurePathExists;
+    /**确保路径存在 不存在时创建 同步
+     * @param {string} filePath - 待验证的路径
+     * @returns {boolean} - 是否成功执行 创建或已存在
+     */
+    function ensurePathExistsSync(filePath, isDir) {
+        if (pathExistsSync(filePath))
+            return true;
+        return createPathSync(filePath, isDir);
     }
-    return JSON.parse(str);
-}
-exports.loadJSONFileSync = loadJSONFileSync;
-async function loadJSONFile(filePath, def) {
-    if (path.extname(filePath) !== '.json')
-        filePath += '.json';
-    let str = "";
-    // 判断文件路径是否存在
-    if (await pathExists(filePath))
-        str = await fs.promises.readFile(filePath, "utf-8");
-    // 如果不存在则返回默认值
-    if (str == "" || str == null) {
-        if (def !== undefined)
-            return def;
-        return {};
+    UtilFT.ensurePathExistsSync = ensurePathExistsSync;
+    function loadJSONFileSync(filePath, def) {
+        if (path.extname(filePath) !== '.json')
+            filePath += '.json';
+        let str = "";
+        // 判断文件路径是否存在
+        if (pathExistsSync(filePath))
+            str = fs.readFileSync(filePath, "utf-8");
+        // 如果不存在则返回默认值
+        if (str == "" || str == null) {
+            if (def !== undefined)
+                return def;
+            return {};
+        }
+        return JSON.parse(str);
     }
-    return JSON.parse(str);
-}
-exports.loadJSONFile = loadJSONFile;
-/**写入JSON文件
- * void (string,Object)
- * @async
- * @param {string} filePath - 文件路径
- * @param {JToken} token 	    - 所要写入的JToken
- * @returns {Promise<void>}
- */
-async function writeJSONFile(filePath, token) {
-    let str = (0, UtilInterfaces_1.stringifyJToken)(token);
-    if (path.extname(filePath) !== '.json')
-        filePath += '.json';
-    // 判断文件路径是否存在 不存在则创建
-    if (!(await pathExists(filePath)))
-        await createPath(filePath);
-    // 写入文件
-    try {
-        await fs.promises.writeFile(filePath, str);
-        UtilLogger_1.SLogger.verbose(`${filePath} writeJSONFile 成功`);
+    UtilFT.loadJSONFileSync = loadJSONFileSync;
+    async function loadJSONFile(filePath, def) {
+        if (path.extname(filePath) !== '.json')
+            filePath += '.json';
+        let str = "";
+        // 判断文件路径是否存在
+        if (await pathExists(filePath))
+            str = await fs.promises.readFile(filePath, "utf-8");
+        // 如果不存在则返回默认值
+        if (str == "" || str == null) {
+            if (def !== undefined)
+                return def;
+            return {};
+        }
+        return JSON.parse(str);
     }
-    catch (err) {
-        UtilLogger_1.SLogger.error(`${filePath} writeJSONFile 错误`, err);
+    UtilFT.loadJSONFile = loadJSONFile;
+    /**写入JSON文件
+     * void (string,Object)
+     * @async
+     * @param {string} filePath - 文件路径
+     * @param {JToken} token 	    - 所要写入的JToken
+     * @returns {Promise<void>}
+     */
+    async function writeJSONFile(filePath, token) {
+        let str = (0, UtilInterfaces_1.stringifyJToken)(token);
+        if (path.extname(filePath) !== '.json')
+            filePath += '.json';
+        // 判断文件路径是否存在 不存在则创建
+        if (!(await pathExists(filePath)))
+            await createPath(filePath);
+        // 写入文件
+        try {
+            await fs.promises.writeFile(filePath, str);
+            UtilLogger_1.SLogger.verbose(`${filePath} writeJSONFile 成功`);
+        }
+        catch (err) {
+            UtilLogger_1.SLogger.error(`${filePath} writeJSONFile 错误`, err);
+        }
     }
-}
-exports.writeJSONFile = writeJSONFile;
-/**搜索路径符合正则表达式的文件
- * @param folder - 文件夹路径
- * @param traitRegex - 正则表达式
- * @returns {Record<string, string>} 文件名与路径的映射
- */
-function fileSearch(folder, traitRegex) {
-    let outMap = {};
-    let subFiles = fs.readdirSync(folder);
-    let regex = new RegExp(traitRegex);
-    for (let subFile of subFiles) {
-        let subFilePath = path.join(folder, subFile);
-        subFilePath = subFilePath.replace(/\\/g, "/");
-        let stat = fs.lstatSync(subFilePath);
-        //判断是否是文件夹，递归调用
-        if (stat.isDirectory()) {
-            let subMap = fileSearch(path.join(subFilePath, path.sep), traitRegex);
-            for (let key in subMap)
-                outMap[key] = subMap[key];
-            continue;
+    UtilFT.writeJSONFile = writeJSONFile;
+    /**搜索路径符合正则表达式的文件
+     * @param folder - 文件夹路径
+     * @param traitRegex - 正则表达式
+     * @returns {Record<string, string>} 文件名与路径的映射
+     */
+    function fileSearch(folder, traitRegex) {
+        let outMap = {};
+        let subFiles = fs.readdirSync(folder);
+        let regex = new RegExp(traitRegex);
+        for (let subFile of subFiles) {
+            let subFilePath = path.join(folder, subFile);
+            subFilePath = subFilePath.replace(/\\/g, "/");
+            let stat = fs.lstatSync(subFilePath);
+            //判断是否是文件夹，递归调用
+            if (stat.isDirectory()) {
+                let subMap = fileSearch(path.join(subFilePath, path.sep), traitRegex);
+                for (let key in subMap)
+                    outMap[key] = subMap[key];
+                continue;
+            }
+            if (regex.test(subFilePath))
+                outMap[subFile] = subFilePath;
         }
-        if (regex.test(subFilePath))
-            outMap[subFile] = subFilePath;
+        return outMap;
     }
-    return outMap;
-}
-exports.fileSearch = fileSearch;
+    UtilFT.fileSearch = fileSearch;
+})(UtilFT = exports.UtilFT || (exports.UtilFT = {}));

package/dist/UtilInterfaces.d.ts CHANGED Viewed

@@ -22,3 +22,9 @@ export declare function stringifyJToken(token: JToken, space?: string | number |
 export type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
 };
+/**翻转K和V */
+export type Inverted<T extends Record<keyof T, string | number | symbol>> = {
+    [K in keyof T as T[K]]: K;
+};
+/**N长度 T类型的元组  */
+export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> = R['length'] extends N ? R : FixedLengthTuple<T, N, [T, ...R]>;

package/package.json CHANGED Viewed

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

package/src/UtilCodecs.ts CHANGED Viewed

@@ -1,10 +1,16 @@
 import * as he from 'html-entities';
 import {get_encoding,Tiktoken} from 'tiktoken';
+/**编码/解码器 */
+export namespace UtilCodec{
 let encoderTurbo:Tiktoken|null = null;
 let encoderDavinci:Tiktoken|null = null;
 const textDecoder = new TextDecoder();
 // 定义一个对象，存储常见的HTML实体和对应的字符
 let htmlEntities:Record<string,string> = {
     "&lt;": "<",
@@ -107,4 +113,6 @@ export function decodeTokenTurbo(arr:Uint32Array):string{
 export function decodeTokenDavinci(arr:Uint32Array):string{
 	initTikTokenEncoder();
 	return textDecoder.decode(encoderDavinci?.decode(arr));
+}
 }

package/src/UtilCom.ts CHANGED Viewed

@@ -4,6 +4,8 @@ import * as http from 'http';
 import { SLogger } from "./UtilLogger";
+/**网络工具 */
+export namespace UtilCom{
 function sPost(type:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
     //转换为毫秒
@@ -102,4 +104,5 @@ export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Prom
  */
 export function shttpPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
     return sPost("http",json,options,timeLimit);
+}
 }

package/src/UtilDecorators.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import { SLogger } from "./UtilLogger";
 /**用于打印方法的调用
  * @returns {void}
  */

package/src/UtilFileTools.ts CHANGED Viewed

@@ -1,9 +1,10 @@
 import * as fs from "fs";
 import * as path from "path";
-import { JArray, JObject, JToken, stringifyJToken } from "./UtilInterfaces";
+import { JObject, JToken, stringifyJToken } from "./UtilInterfaces";
 import { SLogger } from "./UtilLogger";
+/**文件工具 */
+export namespace UtilFT{
 /**验证路径 文件或文件夹 是否存在 异步
  * @async
@@ -218,4 +219,5 @@ export function fileSearch(folder: string, traitRegex: string) {
         if (regex.test(subFilePath)) outMap[subFile] = subFilePath;
     }
     return outMap;
+}
 }

package/src/UtilInterfaces.ts CHANGED Viewed

@@ -25,5 +25,14 @@ export function stringifyJToken(token:JToken,space:string|number|null|undefined=
 }
 /**转为可写的 */
-export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+export type Writeable<T> = {
+	-readonly [P in keyof T]: T[P]
+};
+/**翻转K和V */
+export type Inverted<T extends Record<keyof T, string | number | symbol>> = {
+    [K in keyof T as T[K]]: K;
+};
+/**N长度 T类型的元组  */
+export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> =
+    R['length'] extends N ? R : FixedLengthTuple<T, N, [T, ...R]>;