@zwa73/utils 1.0.223 → 1.0.224

package/dist/mjs/UtilFileTools.mjs

@@ -0,0 +1,407 @@
+import * as fs from "fs";
+import path from 'pathe';
+import * as os from "os";
+import { SLogger } from "./UtilLogger.mjs";
+import * as JSON5 from 'json5';
+import { globSync, glob } from "glob";
+import { UtilFunc } from "./UtilFunctions.mjs";
+import crypto from 'crypto';
+/**文件工具 */
+export var UtilFT;
+(function (UtilFT) {
+    /**验证路径 文件或文件夹 是否存在 异步
+     * @async
+     * @param filePath - 待验证的路径
+     * @returns 是否存在
+     */
+    async function pathExists(filePath) {
+        try {
+            await fs.promises.access(filePath);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    UtilFT.pathExists = pathExists;
+    /**验证路径 文件或文件夹 是否存在 同步
+     * @param filePath - 待验证的路径
+     * @returns - 是否存在
+     */
+    function pathExistsSync(filePath) {
+        try {
+            fs.accessSync(filePath);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    UtilFT.pathExistsSync = pathExistsSync;
+    /**路径不存在时创建路径 以path.sep结尾时创建文件夹 异步
+     * @async
+     * @param filePath - 待创建的路径
+     * @param opt      - 可选参数
+     * @param opt.dir  - 创建一个目录
+     * @returns 是否成功创建
+     */
+    async function createPath(filePath, opt) {
+        if (opt?.dir == 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 });
+            const filehandle = await fs.promises.open(filePath, 'w');
+            await filehandle.close();
+            return true;
+        }
+        catch (e) {
+            SLogger.error("createPath 错误", e);
+            return false;
+        }
+    }
+    UtilFT.createPath = createPath;
+    /**路径不存在时创建路径 以path.sep结尾时创建文件夹 同步
+     * @param filePath - 待创建的路径
+     * @param opt      - 可选参数
+     * @param opt.dir  - 创建一个目录
+     * @returns 是否成功创建
+     */
+    function createPathSync(filePath, opt) {
+        if (opt?.dir == 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) {
+            SLogger.error("createPathSync 错误", e);
+            return false;
+        }
+    }
+    UtilFT.createPathSync = createPathSync;
+    /**确保路径存在 不存在时创建 异步
+     * @async
+     * @param filePath - 待验证的路径
+     * @param opt      - 可选参数
+     * @param opt.dir  - 强制验证一个文件夹
+     * @returns 是否成功执行 创建或已存在
+     */
+    async function ensurePathExists(filePath, opt) {
+        if (await pathExists(filePath))
+            return true;
+        return await createPath(filePath, opt);
+    }
+    UtilFT.ensurePathExists = ensurePathExists;
+    /**确保路径存在 不存在时创建 同步
+     * @param filePath - 待验证的路径
+     * @param opt      - 可选参数
+     * @param opt.dir  - 强制验证一个文件夹
+     * @returns 是否成功执行 创建或已存在
+     */
+    function ensurePathExistsSync(filePath, opt) {
+        if (pathExistsSync(filePath))
+            return true;
+        return createPathSync(filePath, opt);
+    }
+    UtilFT.ensurePathExistsSync = ensurePathExistsSync;
+    function loadJSONFileSync(filePath, opt) {
+        try {
+            if (opt?.forceExt !== true && path.extname(filePath) !== '.json')
+                filePath += '.json';
+            const str = pathExistsSync(filePath)
+                ? fs.readFileSync(filePath, "utf-8")
+                : "";
+            // 如果不存在则返回默认值
+            if (str == "" || str == null) {
+                if (opt?.default !== undefined)
+                    return opt.default;
+                return {};
+            }
+            if (opt?.json5)
+                return JSON5.parse(str);
+            return JSON.parse(str);
+        }
+        catch (e) {
+            SLogger.error(`loadJSONFileSync 错误 filePath:${filePath}`);
+            throw e;
+        }
+    }
+    UtilFT.loadJSONFileSync = loadJSONFileSync;
+    async function loadJSONFile(filePath, opt) {
+        try {
+            if (opt?.forceExt !== true && path.extname(filePath) !== '.json')
+                filePath += '.json';
+            const str = (await pathExists(filePath))
+                ? await fs.promises.readFile(filePath, "utf-8")
+                : "";
+            // 如果不存在则返回默认值
+            if (str == "" || str == null) {
+                if (opt?.default !== undefined)
+                    return opt.default;
+                return {};
+            }
+            if (opt?.json5)
+                return JSON5.parse(str);
+            return JSON.parse(str);
+        }
+        catch (e) {
+            SLogger.error(`loadJSONFile 错误 filePath:${filePath}`);
+            throw e;
+        }
+    }
+    UtilFT.loadJSONFile = loadJSONFile;
+    /**写入JSON文件
+     * @async
+     * @param filePath - 文件路径
+     * @param token    - 所要写入的JToken
+     * @param opt      - 可选参数
+     * @param opt.compress          - 使用紧凑风格 将会用/\uF121\uF122\uF123.+\uF121\uF122\uF123/作为特殊标记, 原始文本内若出现相同格式将会产生错误
+     * @param opt.forceExt          - 不自动修改扩展名为json
+     * @param opt.compressThreshold - 紧凑风格 压缩阈值 默认100
+     */
+    async function writeJSONFile(filePath, token, opt) {
+        const str = UtilFunc.stringifyJToken(token, opt);
+        if (opt?.forceExt !== true && path.extname(filePath) !== '.json')
+            filePath += '.json';
+        // 判断文件路径是否存在 不存在则创建
+        if (!(await pathExists(filePath)))
+            await createPath(filePath);
+        // 写入文件
+        try {
+            await fs.promises.writeFile(filePath, str);
+            SLogger.verbose(`${filePath} writeJSONFile 成功`);
+        }
+        catch (err) {
+            SLogger.error(`${filePath} writeJSONFile 错误`, err);
+        }
+    }
+    UtilFT.writeJSONFile = writeJSONFile;
+    /**保证路径为某个风格
+     * @param filePath - 输入路径
+     * @param style    - 目标风格 undefined 时不改变
+     * @returns 新的符合目标风格的路径
+     */
+    function stylizePath(filePath, style) {
+        if (style === undefined)
+            return filePath;
+        return UtilFunc.match(style, {
+            posix: (nor) => filePath.replaceAll("\\", "/"),
+            win32: (nor) => filePath.replaceAll("/", "\\"),
+        });
+    }
+    UtilFT.stylizePath = stylizePath;
+    /**保证路径为POSIX风格
+     * @param filePath - 输入路径
+     * @returns 新的符合POSIX风格的路径
+     */
+    function posixizePath(filePath) {
+        return stylizePath(filePath, 'posix');
+    }
+    UtilFT.posixizePath = posixizePath;
+    /**保证路径为Win32风格
+     * @param filePath - 输入路径
+     * @returns 新的符合Win32风格的路径
+     */
+    function win32izePath(filePath) {
+        return stylizePath(filePath, 'win32');
+    }
+    UtilFT.win32izePath = win32izePath;
+    /**保证路径为当前系统风格
+     * @param filePath - 输入路径
+     * @returns 新的符合当前系统风格的路径
+     */
+    function currosizePath(filePath) {
+        const system = os.platform();
+        if (system === 'win32')
+            return win32izePath(filePath);
+        return posixizePath(filePath);
+    }
+    UtilFT.currosizePath = currosizePath;
+    /**逐级寻找node_modules文件夹
+     * @param basePath - 基础位置
+     * @param extpaths - 额外的路径 如 .bin
+     * @returns node_modules文件夹路径 包含额外路径
+     */
+    async function findNodeModulesDir(basePath, ...extpaths) {
+        let currentDir = basePath;
+        while (currentDir) {
+            const nodeModulesPath = path.join(currentDir, 'node_modules', ...extpaths);
+            if (await UtilFT.pathExists(nodeModulesPath))
+                return nodeModulesPath;
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir)
+                break;
+            currentDir = parentDir;
+        }
+        return undefined;
+    }
+    UtilFT.findNodeModulesDir = findNodeModulesDir;
+    /**搜索路径符合正则表达式的文件
+     * @param dir           - 起始目录
+     * @param traitRegex    - 正则表达式
+     * @param opt           - 可选参数
+     * @param opt.recursive - 搜索子目录
+     * @returns 文件名路径数组
+     */
+    async function fileSearchRegex(dir, traitRegex, opt) {
+        const fixopt = Object.assign({ recursive: true, nodir: true }, opt);
+        //如果使用 g 会导致 RegExp.lastIndex 更改, 将会导致匹配错误
+        const regex = new RegExp(traitRegex);
+        const recursive = async (curPath) => {
+            const subDir = path.join(dir, curPath);
+            const subFiles = await fs.promises.readdir(subDir, { withFileTypes: true });
+            const matchFiles = await Promise.all(subFiles.map(async (subFile) => {
+                const subFilePath = path.join(subDir, subFile.name);
+                const nextPath = path.join(curPath, subFile.name);
+                //判断是否是文件夹，递归调用
+                if (subFile.isDirectory() && fixopt.recursive) {
+                    if (fixopt.nodir)
+                        return recursive(nextPath);
+                    return [nextPath, ...await recursive(nextPath)];
+                }
+                if (regex.test(nextPath))
+                    return [subFilePath];
+                return [undefined];
+            }));
+            return matchFiles.flat()
+                .filter(v => v != undefined)
+                .map(fp => path.normalize(fp));
+        };
+        return recursive('');
+    }
+    UtilFT.fileSearchRegex = fileSearchRegex;
+    /**搜索路径符合正则表达式的文件 同步版本
+     * @param dir           - 起始目录
+     * @param traitRegex    - 正则表达式
+     * @param opt           - 可选参数
+     * @param opt.relative  - 搜索子目录
+     * @returns 文件名路径数组
+     */
+    function fileSearchRegexSync(dir, traitRegex, opt) {
+        const fixopt = Object.assign({ recursive: true, nodir: true }, opt);
+        //如果使用 g 会导致 RegExp.lastIndex 更改, 将会导致匹配错误
+        const regex = new RegExp(traitRegex);
+        const recursive = (curPath) => {
+            const subDir = path.join(dir, curPath);
+            const subFiles = fs.readdirSync(subDir, { withFileTypes: true });
+            const matchFiles = subFiles.map(subFile => {
+                const subFilePath = path.join(subDir, subFile.name);
+                const nextPath = path.join(curPath, subFile.name);
+                //判断是否是文件夹，递归调用
+                if (subFile.isDirectory() && fixopt.recursive) {
+                    if (fixopt.nodir)
+                        return recursive(nextPath);
+                    return [nextPath, ...recursive(nextPath)];
+                }
+                if (regex.test(nextPath))
+                    return [subFilePath];
+                return [undefined];
+            });
+            return matchFiles.flat()
+                .filter(v => v != undefined)
+                .map(fp => path.normalize(fp));
+        };
+        return recursive('');
+    }
+    UtilFT.fileSearchRegexSync = fileSearchRegexSync;
+    /**搜索符合Glob匹配的文件
+     * @param dir         - 起始目录
+     * @param globPattern - glob匹配
+     * @param opt         - 可选参数
+     * @param opt.ignore    - 忽略的文件
+     * @param opt.relative  - 忽略目录 默认 true
+     * @param opt.nodir     - 忽略大小写 默认 跟随系统 mac/win为true 其他false
+     * @returns 文件绝对路径数组
+     */
+    async function fileSearchGlob(dir, globPattern, opt) {
+        const fixedPath = typeof globPattern === "string"
+            ? path.join(dir, globPattern)
+            : globPattern.map(p => path.join(dir, p));
+        return (await glob(fixedPath, { absolute: true, ...(opt ?? {}) }))
+            .map(filePath => path.normalize(filePath));
+    }
+    UtilFT.fileSearchGlob = fileSearchGlob;
+    /**搜索符合Glob匹配的文件 同步版本
+     * @param dir         - 起始目录
+     * @param globPattern - glob匹配
+     * @param opt         - 可选参数
+     * @param opt.ignore    - 忽略的文件
+     * @param opt.relative  - 忽略目录 默认 true
+     * @param opt.nodir     - 忽略大小写 默认 跟随系统 mac/win为true 其他false
+     * @returns 文件绝对路径数组
+     */
+    function fileSearchGlobSync(dir, globPattern, opt) {
+        const fixedPath = typeof globPattern === "string"
+            ? path.join(dir, globPattern)
+            : globPattern.map(p => path.join(dir, p));
+        return globSync(fixedPath, { absolute: true, ...(opt ?? {}) })
+            .map(filePath => path.normalize(filePath));
+    }
+    UtilFT.fileSearchGlobSync = fileSearchGlobSync;
+    /**是一个有效的文件路径
+     * @param filePath - 需要验证的文件路径
+     */
+    function isValidFilePath(filePath) {
+        if (filePath.length > 255)
+            return false;
+        const invalidCharacters = ['<', '>', '"', '|', '?', '*'];
+        for (const invalidCharacter of invalidCharacters) {
+            if (filePath.includes(invalidCharacter))
+                return false;
+        }
+        return true;
+    }
+    UtilFT.isValidFilePath = isValidFilePath;
+    /**计算文件的部分md5
+     * @param filePath   - 目标文件路径
+     * @param opt        - 可选参数
+     * @param opt.algorithm  - hash算法 默认md5
+     * @param opt.sampled    - 抽取部分计算 默认false
+     * @param opt.chunkSize  - 抽取的块大小 默认1024
+     * @param opt.chunkCount - 抽取的块的数量 默认10
+     */
+    async function calculateHash(filePath, opt) {
+        const { algorithm = "md5", chunkSize = 1024, chunkCount = 10, sampled = false } = opt ?? {};
+        const chash = async (filePath) => new Promise((resolve, reject) => {
+            const hash = crypto.createHash(algorithm);
+            const stream = fs.createReadStream(filePath);
+            stream.on("data", (data) => hash.update(data));
+            stream.on("end", () => resolve(hash.digest("hex")));
+            stream.on("error", reject);
+        });
+        if (!sampled)
+            return chash(filePath);
+        const stats = await fs.promises.stat(filePath);
+        const totalSize = stats.size;
+        //抽取量大于文件大小则直接计算完整hash
+        if (totalSize < chunkSize * chunkCount)
+            return chash(filePath);
+        const poslist = Array.from({ length: chunkCount }, (_, i) => Math.floor((totalSize / chunkCount) * i));
+        const hash = crypto.createHash(algorithm);
+        for (const pos of poslist) {
+            const buffer = await new Promise((resolve, reject) => {
+                const stream = fs.createReadStream(filePath, {
+                    start: pos,
+                    end: Math.min(pos + chunkSize - 1, totalSize - 1),
+                    highWaterMark: chunkSize,
+                });
+                const chunks = [];
+                stream.on("data", (chunk) => chunks.push(chunk));
+                stream.on("end", () => resolve(Buffer.concat(chunks)));
+                stream.on("error", reject);
+            });
+            hash.update(buffer);
+        }
+        return hash.digest("hex");
+    }
+    UtilFT.calculateHash = calculateHash;
+})(UtilFT || (UtilFT = {}));

package/dist/mjs/UtilFunctions.mjs

@@ -0,0 +1,138 @@
+import * as crypto from "crypto";
+import * as cp from "child_process";
+import { None } from "./UtilSymbol.mjs";
+import opath from 'path';
+import { UtilFT } from "./UtilFileTools.mjs";
+import { SLogger } from "./UtilLogger.mjs";
+import { JsFunc } from "@zwa73/js-utils";
+import { composeClassPart } from "@zwa73/modular-mixer";
+const HashAlgorithmList = [
+    'RSA-MD5', 'RSA-RIPEMD160', 'RSA-SHA1', 'RSA-SHA1-2', 'RSA-SHA224',
+    'RSA-SHA256', 'RSA-SHA3-224', 'RSA-SHA3-256', 'RSA-SHA3-384', 'RSA-SHA3-512',
+    'RSA-SHA384', 'RSA-SHA512', 'RSA-SHA512/224', 'RSA-SHA512/256', 'RSA-SM3',
+    'blake2b512', 'blake2s256', 'id-rsassa-pkcs1-v1_5-with-sha3-224',
+    'id-rsassa-pkcs1-v1_5-with-sha3-256', 'id-rsassa-pkcs1-v1_5-with-sha3-384',
+    'id-rsassa-pkcs1-v1_5-with-sha3-512', 'md5', 'md5-sha1',
+    'md5WithRSAEncryption', 'ripemd', 'ripemd160', 'ripemd160WithRSA', 'rmd160',
+    'sha1', 'sha1WithRSAEncryption', 'sha224', 'sha224WithRSAEncryption',
+    'sha256', 'sha256WithRSAEncryption', 'sha3-224', 'sha3-256', 'sha3-384',
+    'sha3-512', 'sha384', 'sha384WithRSAEncryption', 'sha512', 'sha512-224',
+    'sha512-224WithRSAEncryption', 'sha512-256', 'sha512-256WithRSAEncryption',
+    'sha512WithRSAEncryption', 'shake128', 'shake256', 'sm3',
+    'sm3WithRSAEncryption', 'ssl3-md5', 'ssl3-sha1'
+];
+/**常用函数 */
+class _UtilFunc {
+    /**计算Hash
+     * @param str    - 待计算的字符串
+     * @param method - hash算法
+     * @returns hash
+     */
+    static calcHash(str, opt) {
+        const { algorithm = "md5" } = opt ?? {};
+        return crypto.createHash(algorithm).update(str).digest('hex');
+    }
+    /**是否需要检查环境 */
+    static checkEnv = true;
+    /**是否有正在运行的exec */
+    static originalExecTitle = None;
+    /**封装的 cp.spawn 执行一段指令，指令运行时实时返回输出
+     * @param command - 指令文本
+     * @param opt     - 可选参数
+     * @param opt.outlvl       - 普通输出的日志等级
+     * @param opt.errlvl       - 错误的日志等级
+     * @param opt.nodeModules  - nodeModules文件夹路径
+     * @param opt.cwd          - 执行目录
+     */
+    static async exec(command, opt) {
+        return new Promise(async (resolve, reject) => {
+            // 创建一个新的环境变量对象，并将项目的 node_modules/.bin 目录添加到 PATH 环境变量中
+            const env = Object.create(process.env);
+            const penv = opt?.nodeModules
+                ? opath.join(UtilFT.currosizePath(opt.nodeModules), '.bin')
+                : UtilFT.currosizePath(await UtilFunc.memoize(UtilFT.findNodeModulesDir)(process.cwd(), '.bin') ?? '');
+            if (_UtilFunc.checkEnv && (penv == "" || !await UtilFT.pathExists(penv))) {
+                SLogger.warn(`UtilFunc.exec 错误, 没有检测到 node_modules/.bin 环境 penv:${penv}`);
+                _UtilFunc.checkEnv = false;
+            }
+            env.PATH = penv + opath.delimiter + env.PATH;
+            // 保存原来的标题
+            _UtilFunc.originalExecTitle = _UtilFunc.originalExecTitle == None
+                ? process.title
+                : _UtilFunc.originalExecTitle;
+            const cwd = opt?.cwd ?? process.cwd();
+            const child = cp.spawn(command, { shell: true, env, cwd });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (data) => {
+                stdout += data;
+                if (opt?.outlvl)
+                    SLogger.log(opt?.outlvl, data.toString());
+            });
+            child.stderr.on('data', (data) => {
+                stderr += data;
+                if (opt?.errlvl)
+                    SLogger.log(opt?.errlvl, data.toString());
+            });
+            child.on('error', reject);
+            child.on('close', (code) => {
+                if (_UtilFunc.originalExecTitle != None) {
+                    process.title = _UtilFunc.originalExecTitle;
+                    _UtilFunc.originalExecTitle = None;
+                }
+                if (code !== 0)
+                    SLogger.warn(`UtilFunc.exec 命令:"${command}" 结束 代码为:${code}`);
+                resolve({ stdout, stderr });
+            });
+        });
+    }
+    static publicIp;
+    /**获取当前公网ipv4 */
+    static async getPublicIpv4() {
+        if (_UtilFunc.publicIp === undefined)
+            _UtilFunc.publicIp = await _UtilFunc.dynamicImport('public-ip');
+        //if(_UtilFunc.publicIp===undefined)
+        //    _UtilFunc.publicIp = await import("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) {
+        const mod = await eval(`import('${moduleName}')`);
+        if ('default' in mod)
+            return mod.default;
+        return mod;
+    }
+}
+const key = '__jsUtils';
+const fields = Object.getOwnPropertyNames(JsFunc).filter(k => !['length', 'prototype', 'name'].includes(k));
+export const UtilFunc = composeClassPart({
+    base: _UtilFunc,
+    mixin: JsFunc,
+    key, fields
+});
+//void (async ()=>{
+//    const p1 =  UtilFunc.getNeverResolvedPromise();
+//    const p2 =  UtilFunc.getNeverResolvedPromise();
+//    const p3 =  JsFunc.getNeverResolvedPromise();
+//    const p4 =  JsFunc.getNeverResolvedPromise();
+//    console.log(p1==p2);
+//    console.log(p2==p3);
+//    console.log(p3==p4);
+//    console.log(p3);
+//    console.log(2345);
+//})();