@zwa73/utils 1.0.26 → 1.0.28

package/dist/UtilCom.js

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

package/dist/UtilFileTools.d.ts

@@ -0,0 +1,79 @@
+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>;

package/dist/UtilFileTools.js

@@ -0,0 +1,191 @@
+"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;
+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;
+    }
+}
+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 });
+            return true;
+        }
+        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.promises.open(filePath, 'w');
+        return true;
+    }
+    catch (e) {
+        console.log("createPath 错误");
+        console.log(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 });
+            return true;
+        }
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.openSync(filePath, 'w');
+        return true;
+    }
+    catch (e) {
+        console.log("createPath 错误");
+        console.log(e);
+        return false;
+    }
+}
+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 {};
+    }
+    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 {};
+    }
+    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.info(`${filePath} writeJSONFile 成功`);
+    }
+    catch (err) {
+        UtilLogger_1.SLogger.error(`${filePath} writeJSONFile 错误`)
+            .error(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;
+        }
+        if (regex.test(subFilePath))
+            outMap[subFile] = subFilePath;
+    }
+    return outMap;
+}
+exports.fileSearch = fileSearch;

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { JObject, JToken } from "./UtilInterfaces";
+import { JToken } from "./UtilInterfaces";
 /**获取当前时间戳
  * number ()
  * @returns {number} 时间戳
@@ -12,78 +12,6 @@ export declare function getTime(): number;
  * @returns {T} - 最终值
  */
 export declare function initField<T>(obj: Record<string, T>, field: string, defaultVal: T): T;
-/**验证路径 文件或文件夹 是否存在 异步
- * @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>;
 /**生成一串uuid
  * string ()
  * @returns {string} uuid
@@ -112,9 +40,3 @@ export declare function isSafeNumber(num: number): boolean;
  * @returns {Promise<boolean>}
  */
 export declare function sleep(timeMs: number): Promise<boolean>;
-/**搜索路径符合正则表达式的文件
- * @param folder - 文件夹路径
- * @param traitRegex - 正则表达式
- * @returns {Record<string, string>} 文件名与路径的映射
- */
-export declare function fileSearch(folder: string, traitRegex: string): Record<string, string>;