@zwa73/utils 1.0.26 → 1.0.28

package/dist/UtilFunctions.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileSearch = exports.sleep = exports.isSafeNumber = exports.deepClone = exports.calcHash = exports.genUUID = exports.writeJSONFile = exports.loadJSONFile = exports.loadJSONFileSync = exports.ensurePathExistsSync = exports.ensurePathExists = exports.createPathSync = exports.createPath = exports.pathExistsSync = exports.pathExists = exports.initField = exports.getTime = void 0;
-const fs = require("fs");
+exports.sleep = exports.isSafeNumber = exports.deepClone = exports.calcHash = exports.genUUID = exports.initField = exports.getTime = void 0;
 const crypto = require("crypto");
-const path = require("path");
-const UtilInterfaces_1 = require("./UtilInterfaces");
 /**获取当前时间戳
  * number ()
  * @returns {number} 时间戳
@@ -26,164 +23,6 @@ function initField(obj, field, defaultVal) {
     return obj[field];
 }
 exports.initField = initField;
-/**验证路径 文件或文件夹 是否存在 异步
- * @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);
-        console.log(`${filePath} writeJSONFile 成功`);
-    }
-    catch (err) {
-        console.log(`${filePath} writeJSONFile 错误`);
-        console.log(err);
-    }
-}
-exports.writeJSONFile = writeJSONFile;
 /**生成一串uuid
  * string ()
  * @returns {string} uuid
@@ -235,29 +74,3 @@ async function sleep(timeMs) {
     });
 }
 exports.sleep = sleep;
-/**搜索路径符合正则表达式的文件
- * @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/UtilInterfaces.d.ts

@@ -18,15 +18,3 @@ export interface IJData {
  * @returns 转换完成的字符串
  */
 export declare function stringifyJToken(token: JToken, space?: string | number | null | undefined): string;
-/**未知格式的Object*/
-export type AnyObject = {
-    [key: string]: any;
-};
-/**用于存储消息的Entry
- * 暂时存于Util
- * 未来应转入LaMChar中
-*/
-export type MessageEntity = {
-    role: string;
-    content: string;
-};

package/dist/UtilLogger.d.ts

@@ -0,0 +1,115 @@
+/**log等级 undefined相当于 silly */
+export type LogLevel = "fatal" | "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly" | undefined;
+export declare class SLogger {
+    /**获取一个Logger，如不存在则用默认参数创建
+     * @param {string} name  - logger的名称 默认default
+     * @returns {SLogger}    - 获取的logger
+     */
+    static getLogger(name?: string): SLogger;
+    /**创建Logger
+     * @param {string} name             - logger的名称 默认default
+     * @param {LogLevel} consoleLevel   - 输出到控制台的最低等级 默认info
+     * @param {string} outFloder        - log的输出文件夹路径 如./log/
+     * @param {LogLevel} fileLevel      - 输出到文件的最低等级   默认info
+     * @returns {SLogger} - 创建完成的logger
+     */
+    static createLogger(name?: string, consoleLevel?: LogLevel, outFloder?: string, fileLevel?: LogLevel): SLogger;
+    private constructor();
+    private _logger;
+    /**记录Logger的表 */
+    private static readonly loggerTable;
+    /**产生一条对应等级的log 返回自身
+     * @param {LogLevel} level      - log等级
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger} - 自身
+     */
+    log(level: LogLevel, ...messages: Array<any>): SLogger;
+    /**产生一条fatal等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    fatal(...messages: Array<any>): SLogger;
+    /**产生一条error等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    error(...messages: Array<any>): SLogger;
+    /**产生一条warn等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    warn(...messages: Array<any>): SLogger;
+    /**产生一条info等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    info(...messages: Array<any>): SLogger;
+    /**产生一条http等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    http(...messages: Array<any>): SLogger;
+    /**产生一条verbose等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger} - 自身
+     */
+    verbose(...messages: Array<any>): SLogger;
+    /**产生一条debug等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    debug(...messages: Array<any>): SLogger;
+    /**产生一条silly等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    silly(...messages: Array<any>): SLogger;
+    /**名称为default的slogger实例 */
+    private static get defaultInstance();
+    /**让名称为default的logger 产生一条对应等级的log 返回自身
+     * @param {LogLevel} level - log等级
+     * @param {Array<any>} messages    - log消息
+     * @returns {SLogger}      - 自身
+     */
+    static log(level: LogLevel, ...messages: Array<any>): SLogger;
+    /**让名称为default的logger 产生一条fatal等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static fatal(...messages: Array<any>): SLogger;
+    /**让名称为default的logger 产生一条error等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static error(...messages: Array<any>): SLogger;
+    /**让名称为default的logger 产生一条warn等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static warn(...messages: Array<any>): SLogger;
+    /**让名称为default的logger 产生一条info等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static info(...messages: Array<any>): SLogger;
+    /**让名称为default的logger 产生一条http等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static http(...messages: Array<any>): SLogger;
+    /**让名称为default的logger 产生一条verbose等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static verbose(...messages: Array<any>): SLogger;
+    /**让名称为default的logger 产生一条debug等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static debug(...messages: Array<any>): SLogger;
+    /**让名称为default的logger 产生一条silly等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static silly(...messages: Array<any>): SLogger;
+}

package/dist/UtilLogger.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLogger = void 0;
+const path = require("path");
+const winston = require("winston");
+const DailyRotateFile = require("winston-daily-rotate-file");
+const logLevels = {
+    fatal: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    http: 4,
+    verbose: 5,
+    debug: 6,
+    silly: 7
+};
+const colorizer = winston.format.colorize();
+colorizer.addColors({
+    fatal: 'bold yellow redBG',
+    error: 'bold yellow',
+    warn: 'yellow',
+    info: 'white',
+    debug: 'bold cyan',
+    silly: 'bold magenta'
+});
+class SLogger {
+    /**获取一个Logger，如不存在则用默认参数创建
+     * @param {string} name  - logger的名称 默认default
+     * @returns {SLogger}    - 获取的logger
+     */
+    static getLogger(name = "default") {
+        let out = SLogger.loggerTable[name];
+        if (out == null) {
+            SLogger.createLogger(name);
+            out = SLogger.loggerTable[name];
+        }
+        return out;
+    }
+    /**创建Logger
+     * @param {string} name             - logger的名称 默认default
+     * @param {LogLevel} consoleLevel   - 输出到控制台的最低等级 默认info
+     * @param {string} outFloder        - log的输出文件夹路径 如./log/
+     * @param {LogLevel} fileLevel      - 输出到文件的最低等级   默认info
+     * @returns {SLogger} - 创建完成的logger
+     */
+    static createLogger(name = "default", consoleLevel = "info", outFloder, fileLevel = "info") {
+        const transports = [];
+        if (outFloder != null) {
+            const fileFormat = winston.format.combine(winston.format.timestamp({ format: 'YY-MM-DD HH:mm:ss' }), winston.format.printf((info) => {
+                const level = info.level.toUpperCase();
+                const message = info.message;
+                //格式化
+                let format = `[${info.timestamp}] [${level}]: `;
+                let space = "";
+                for (let cha of format)
+                    space += " ";
+                let messageList = message.split("\n");
+                return `[${info.timestamp}] [${level.toUpperCase()}]: ${messageList.join("\n" + space)}`;
+            }));
+            transports.push(new DailyRotateFile({
+                filename: path.join(outFloder, 'log-%DATE%.txt'),
+                datePattern: 'YYYY-MM-DD',
+                level: fileLevel,
+                format: fileFormat,
+            }));
+        }
+        const consoleFormat = winston.format.combine(winston.format.timestamp({ format: 'YY-MM-DD HH:mm:ss' }), winston.format.printf((info) => {
+            const level = info.level.toUpperCase();
+            const message = info.message;
+            const colorizedLevel = colorizer.colorize(info.level, level);
+            //格式化
+            let format = `[${info.timestamp}] [${level}]: `;
+            let space = "";
+            for (let cha of format)
+                space += " ";
+            let messageList = message.split("\n");
+            messageList[0] = colorizer.colorize(info.level, messageList[0]);
+            for (let i = 1; i < messageList.length; i++)
+                messageList[i] = colorizer.colorize(info.level, messageList[i]);
+            return `[${info.timestamp}] [${colorizedLevel}]: ${messageList.join("\n" + space)}`;
+        }));
+        transports.push(new winston.transports.Console({
+            level: consoleLevel,
+            format: consoleFormat,
+        }));
+        const logger = winston.createLogger({
+            levels: logLevels,
+            transports: transports,
+        });
+        const out = new SLogger();
+        out._logger = logger;
+        if (SLogger.loggerTable[name] != null) {
+            let old = SLogger.loggerTable[name];
+            old._logger.transports.forEach(tp => {
+                if (tp.close != null)
+                    tp.close();
+            });
+        }
+        SLogger.loggerTable[name] = out;
+        return out;
+    }
+    constructor() { }
+    _logger = null;
+    /**记录Logger的表 */
+    static loggerTable = {};
+    //———————————————————— function ——————————————————————//
+    /**产生一条对应等级的log 返回自身
+     * @param {LogLevel} level      - log等级
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger} - 自身
+     */
+    log(level, ...messages) {
+        level = level || "silly";
+        let strMessages = [];
+        for (let message of messages) {
+            let out;
+            if (message == null)
+                out = `<${typeof message}> ${typeof message}`;
+            else if (typeof message !== "string")
+                out = `<${typeof message}> ${message.toString()}`;
+            else
+                out = message;
+            strMessages.push(out);
+        }
+        let outMessage = strMessages.join("\n");
+        this._logger.log(level, outMessage);
+        return this;
+    }
+    /**产生一条fatal等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    fatal(...messages) {
+        return this.log("fatal", ...messages);
+        ;
+    }
+    /**产生一条error等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    error(...messages) {
+        return this.log("error", ...messages);
+        ;
+    }
+    /**产生一条warn等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    warn(...messages) {
+        return this.log("warn", ...messages);
+        ;
+    }
+    /**产生一条info等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    info(...messages) {
+        return this.log("info", ...messages);
+    }
+    /**产生一条http等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    http(...messages) {
+        return this.log("http", ...messages);
+    }
+    /**产生一条verbose等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger} - 自身
+     */
+    verbose(...messages) {
+        return this.log("verbose", ...messages);
+    }
+    /**产生一条debug等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    debug(...messages) {
+        return this.log("debug", ...messages);
+    }
+    /**产生一条silly等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    silly(...messages) {
+        return this.log("silly", ...messages);
+    }
+    //———————————————————— static ——————————————————————//
+    /**名称为default的slogger实例 */
+    static get defaultInstance() {
+        if (SLogger.loggerTable.default == null)
+            SLogger.createLogger();
+        return SLogger.loggerTable.default;
+    }
+    /**让名称为default的logger 产生一条对应等级的log 返回自身
+     * @param {LogLevel} level - log等级
+     * @param {Array<any>} messages    - log消息
+     * @returns {SLogger}      - 自身
+     */
+    static log(level, ...messages) {
+        level = level || "silly";
+        this.defaultInstance.log(level, ...messages);
+        return this.defaultInstance;
+    }
+    /**让名称为default的logger 产生一条fatal等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static fatal(...messages) {
+        return this.log("fatal", ...messages);
+        ;
+    }
+    /**让名称为default的logger 产生一条error等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static error(...messages) {
+        return this.log("error", ...messages);
+        ;
+    }
+    /**让名称为default的logger 产生一条warn等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static warn(...messages) {
+        return this.log("warn", ...messages);
+        ;
+    }
+    /**让名称为default的logger 产生一条info等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static info(...messages) {
+        return this.log("info", ...messages);
+    }
+    /**让名称为default的logger 产生一条http等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static http(...messages) {
+        return this.log("http", ...messages);
+    }
+    /**让名称为default的logger 产生一条verbose等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static verbose(...messages) {
+        return this.log("verbose", ...messages);
+    }
+    /**让名称为default的logger 产生一条debug等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static debug(...messages) {
+        return this.log("debug", ...messages);
+    }
+    /**让名称为default的logger 产生一条silly等级的log 返回自身
+     * @param {Array<any>} messages - log消息
+     * @returns {SLogger}   - 自身
+     */
+    static silly(...messages) {
+        return this.log("silly", ...messages);
+    }
+}
+exports.SLogger = SLogger;

package/dist/index.d.ts

@@ -5,3 +5,5 @@ export * from './UtilCom';
 export * from './UtilCodecs';
 export * from './UtilFfmpegTools';
 export * from './UtilDecorators';
+export * from './UtilFileTools';
+export * from './UtilLogger';

package/dist/index.js

@@ -21,3 +21,5 @@ __exportStar(require("./UtilCom"), exports);
 __exportStar(require("./UtilCodecs"), exports);
 __exportStar(require("./UtilFfmpegTools"), exports);
 __exportStar(require("./UtilDecorators"), exports);
+__exportStar(require("./UtilFileTools"), exports);
+__exportStar(require("./UtilLogger"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zwa73/utils",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "my utils",
   "main": "index.js",
   "scripts": {
@@ -19,7 +19,9 @@
     "html-entities": "^2.3.3",
     "http-proxy-agent": "^5.0.0",
     "https-proxy-agent": "^5.0.1",
-    "tiktoken": "^1.0.7"
+    "tiktoken": "^1.0.7",
+    "winston": "^3.10.0",
+    "winston-daily-rotate-file": "^4.7.1"
   },
   "devDependencies": {
     "@types/node": "^18.16.3"