@zwa73/dev-utils 1.0.94 → 1.0.95

package/data/template/base/tsconfig.json

@@ -6,8 +6,6 @@
     "module": "node16",
     "moduleResolution": "node16",
     "esModuleInterop": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
     "skipLibCheck": true,
     "baseUrl": ".",
     "paths": {

package/data/template/cjs/tsconfig.json

@@ -6,8 +6,6 @@
     "module": "node16",
     "moduleResolution": "node16",
     "esModuleInterop": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
     "skipLibCheck": true,
     "baseUrl": ".",
     "paths": {

package/dist/Command/Archive.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+/**归档命令定义 */
+export declare const CmdArchive: (program: Command) => Command;

package/dist/Command/Archive.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmdArchive = void 0;
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("@zwa73/utils");
+const pathe_1 = __importDefault(require("pathe"));
+/**命令执行选项 */
+const execopt = { nodeModules: 'None' };
+/**归档命令定义 */
+const CmdArchive = (program) => program
+    .command("Archive")
+    .alias("compress")
+    .alias("archive")
+    .description("归档并压缩文件/目录")
+    .argument("<input...>", "文件或目录")
+    .option("-g, --glob", "批处理模式", false)
+    .option("-d, --dir", "glob 模式下是否包含目录", false)
+    .option("-k, --keep", "是否保留tar打包文件", false)
+    .option("--no-test", "不测试文件", false)
+    .option("-p, --parallel <num>", "并行数，默认 1", parseInt, 1)
+    .option("-f, --format <fmt>", `归档格式: ${Object.keys(compressFuncTable).map(v => ` ${v} `).join('|')}`, "zstd")
+    .action(async (input, opt) => {
+    if (!Object.keys(compressFuncTable).includes(opt.format)) {
+        utils_1.SLogger.warn(`${opt.format} 不是有效的格式`);
+        return;
+    }
+    if (opt.parallel == null || opt.parallel < 1 || isNaN(opt.parallel)) {
+        utils_1.SLogger.warn(`${opt.parallel} 不是有效的并行数`);
+        return;
+    }
+    const cwd = process.cwd();
+    const dirlist = input.map(v => pathe_1.default.dirname(pathe_1.default.resolve(cwd, v)));
+    if (dirlist.some(v => v != dirlist[0])) {
+        utils_1.SLogger.warn(`输入路径必须在同一目录下`);
+        return;
+    }
+    // 批处理模式
+    if (opt.glob) {
+        const list = (await utils_1.UtilFT.fileSearchGlob(cwd, input, {
+            nodir: opt.dir ? false : undefined
+        })).map(fp => ({
+            list: [pathe_1.default.basename(fp)],
+            rel: pathe_1.default.relative(cwd, fp),
+            abs: fp,
+            base: pathe_1.default.basename(fp),
+            absdir: pathe_1.default.dirname(fp),
+        }));
+        if (!list.length)
+            return void utils_1.SLogger.warn(`未找到任何匹配项: ${input}`);
+        await utils_1.Stream.from(list, opt.parallel).map(async (input) => {
+            return compressOne({ input, ...opt }, opt.format);
+        }).apply();
+        return;
+    }
+    const dirfilename = pathe_1.default.basename(pathe_1.default.dirname(input[0]));
+    // 单文件模式
+    await compressOne({ input: {
+            list: input.map(fp => pathe_1.default.basename(fp)),
+            abs: input.length > 1
+                ? pathe_1.default.join(pathe_1.default.resolve(cwd, pathe_1.default.dirname(input[0])), dirfilename)
+                : pathe_1.default.resolve(cwd, input[0]),
+            rel: input.length > 1
+                ? pathe_1.default.join(pathe_1.default.relative(cwd, pathe_1.default.dirname(input[0])), dirfilename)
+                : pathe_1.default.relative(cwd, input[0]),
+            base: input.length > 1
+                ? pathe_1.default.basename(pathe_1.default.dirname(input[0]))
+                : pathe_1.default.basename(input[0]),
+            absdir: pathe_1.default.dirname(pathe_1.default.resolve(cwd, input[0])),
+        }, ...opt }, opt.format);
+});
+exports.CmdArchive = CmdArchive;
+/** 格式化字节大小为人类可读格式 (Windows 风格) */
+const formatSize = (bytes) => {
+    if (bytes === 0)
+        return "0 Bytes";
+    const units = ["Bytes", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    const size = bytes / Math.pow(1024, i);
+    // 只有 Bytes 不保留小数，其他保留两位
+    return `${i === 0 ? size : size.toFixed(2)} ${units[i]}`;
+};
+/** 打印压缩率报告 */
+const logCompressionRatio = async (sourcePath, targetPath) => {
+    try {
+        const sourceStat = await fs_1.default.promises.stat(sourcePath);
+        const targetStat = await fs_1.default.promises.stat(targetPath);
+        const srcSize = sourceStat.size;
+        const tgtSize = targetStat.size;
+        const ratio = ((tgtSize / srcSize) * 100).toFixed(2);
+        utils_1.SLogger.info(`📊 压缩报告: ${formatSize(srcSize)} -> ${formatSize(tgtSize)} (压缩率: ${ratio}%)`);
+    }
+    catch (e) {
+        utils_1.SLogger.warn(`无法计算压缩率: ${e}`);
+    }
+};
+/**检查目标路径是否已存在
+ * @param targetpath 目标路径
+ * @returns 是否存在
+ */
+const exists = async (targetpath) => {
+    if (await utils_1.UtilFT.pathExists(targetpath.abs)) {
+        utils_1.SLogger.warn(`${targetpath.rel} 已经存在`);
+        return true;
+    }
+    return false;
+};
+/**添加后缀名
+ * @param pp  - 输入路径
+ * @param ext - 后缀名
+ * @returns 带后缀名的路径
+ */
+const addExt = (pp, ext) => ({
+    list: pp.list,
+    abs: pathe_1.default.join(pathe_1.default.dirname(pp.abs), `${pp.base}.${ext}`),
+    rel: pathe_1.default.join(pathe_1.default.dirname(pp.rel), `${pp.base}.${ext}`),
+    base: `${pp.base}.${ext}`,
+    absdir: pp.absdir
+});
+/**生成tar文件名
+ * @param pp 输入路径
+ * @returns tar文件名
+ */
+const toTarName = (pp) => addExt(pp, 'tar');
+/**将文件或目录打包为tar
+ * @param pp 输入路径
+ * @param silence 是否静默执行，不输出日志
+ */
+const toTar = async (pp, silence = false) => {
+    const tarPp = toTarName(pp);
+    if (await exists(tarPp))
+        return;
+    const flag = `📦 打包完成: ${tarPp.rel}`;
+    if (!silence)
+        utils_1.SLogger.time(flag);
+    await utils_1.UtilFunc.exec(`tar -cf "${tarPp.base}" ${pp.list.map(v => `"${v}"`).join(' ')}`, { cwd: pp.absdir, ...execopt });
+    if (!silence)
+        utils_1.SLogger.timeEnd(flag);
+};
+/**测试压缩文件完整性
+ * @param input 压缩文件路径
+ */
+const testCmp = async (pp) => {
+    utils_1.SLogger.info(`🔍 开始测试: ${pp.rel}`);
+    const { stderr } = await utils_1.UtilFunc.exec(`7z t "${pp.base}"`, { cwd: pp.absdir, ...execopt });
+    if (stderr.trim().length > 0) {
+        utils_1.SLogger.error(`❌ ${pp.rel} 可能损坏`);
+        utils_1.SLogger.error(stderr);
+    }
+    else {
+        utils_1.SLogger.info(`🟢 ${pp.rel} 测试通过`);
+    }
+};
+/**生成压缩完成标记
+ * @param pp 输入路径
+ * @returns 压缩完成标记文本
+ */
+const cmpFlag = (pp) => `🗃️ 压缩完成: ${pp.rel}`;
+/**压缩队列，确保压缩操作串行执行 */
+const cmpQueue = new utils_1.PromiseQueue({ concurrency: 1 });
+/**通过队列执行压缩命令
+ * @param cmd 要执行的命令
+ * @param flag 日志标记
+ */
+const queueExec = async (cmd, flag, opt) => cmpQueue.enqueue(async () => {
+    utils_1.SLogger.time(flag);
+    await utils_1.UtilFunc.exec(cmd, opt);
+    utils_1.SLogger.timeEnd(flag);
+});
+/**压缩函数映射表 */
+const compressFuncTable = {
+    /**tar格式压缩 */
+    tar: async ({ input, noTest }) => {
+        await toTar(input);
+        const tarName = toTarName(input);
+        if (noTest != true)
+            await testCmp(tarName);
+    },
+    /**zip格式压缩 */
+    zip: async ({ requirePack, input, noTest }) => {
+        const zipPp = addExt(input, 'zip');
+        if (await exists(zipPp))
+            return;
+        await queueExec(`7z a -bd -tzip "${zipPp.base}" ${input.list.map(v => `"${v}"`).join(' ')}`, cmpFlag(zipPp), { cwd: input.absdir, ...execopt });
+        //打印压缩率
+        if (!requirePack)
+            await logCompressionRatio(input.abs, zipPp.abs);
+        if (noTest != true)
+            await testCmp(zipPp);
+    },
+    /**7z格式压缩
+     * 用于百兆级低熵目录压缩
+     * 在百兆级低熵目录表现极佳, 由于免归档快于 tar+zstd, 且压缩率比tar+xz略高
+     * 对于顶点等结构化数据(unity数据)时, 7-zip的实现下, 7z会自动使用delta过滤器, 任意大小下表现比xz强10%左右
+     */
+    '7z': async ({ requirePack, input, noTest }) => {
+        const szPp = addExt(input, '7z');
+        if (await exists(szPp))
+            return;
+        await queueExec(`7z a -bd -t7z "${szPp.base}" ${input.list.map(v => `"${v}"`).join(' ')}`, cmpFlag(szPp), { cwd: input.absdir, ...execopt });
+        //打印压缩率
+        if (!requirePack)
+            await logCompressionRatio(input.abs, szPp.abs);
+        if (noTest != true)
+            await testCmp(szPp);
+    },
+    /**zstd格式压缩
+     * 用于高熵文件(png|ckpt|pth|mp4)压缩
+     * 在任意高熵文件下极快的获得95%左右的压缩率, 相比7z/xz多接近3%
+     * 解压极快
+     */
+    zstd: async ({ requirePack, input, keep, noTest }) => {
+        const pakPp = requirePack ? toTarName(input) : input;
+        const zstdPp = addExt(pakPp, 'zst');
+        if (requirePack && await exists(pakPp))
+            return;
+        if (await exists(zstdPp))
+            return;
+        if (requirePack)
+            await toTar(input);
+        await queueExec(`zstd -q -T0 "${pakPp.base}" -o "${zstdPp.base}"`, cmpFlag(zstdPp), { cwd: pakPp.absdir, ...execopt });
+        //打印压缩率
+        await logCompressionRatio(pakPp.abs, zstdPp.abs);
+        // 清理中间 tar
+        if (requirePack && !keep)
+            await fs_1.default.promises.rm(pakPp.abs, { force: true });
+        if (noTest != true)
+            await testCmp(zstdPp);
+    },
+    /**xz格式压缩
+     * 用于单文件或巨大目录压缩
+     * 在结果为百兆级较小时表现不如7z
+     */
+    xz: async ({ requirePack, input, keep, noTest }) => {
+        const pakPp = requirePack ? toTarName(input) : input;
+        const xzPp = addExt(pakPp, 'xz');
+        if (requirePack && await exists(pakPp))
+            return;
+        if (await exists(xzPp))
+            return;
+        if (requirePack)
+            await toTar(input);
+        await queueExec(`7z a -bd -txz "${xzPp.base}" "${pakPp.base}"`, cmpFlag(xzPp), { cwd: pakPp.absdir, ...execopt });
+        //打印压缩率
+        await logCompressionRatio(pakPp.abs, xzPp.abs);
+        // 清理中间 tar
+        if (requirePack && !keep)
+            await fs_1.default.promises.rm(pakPp.abs, { force: true });
+        if (noTest != true)
+            await testCmp(xzPp);
+    }
+};
+/**单个文件/目录归档逻辑
+ * @param opt 压缩选项
+ * @param format 压缩格式
+ */
+async function compressOne(opt, format) {
+    const { input } = opt;
+    const requirePack = input.list.length > 1 || (await fs_1.default.promises.lstat(opt.input.abs)).isDirectory();
+    utils_1.SLogger.info(`📁 开始归档: ${opt.input.rel}`);
+    const flag = `☑️ 归档完成: ${opt.input.rel}`;
+    utils_1.SLogger.time(flag);
+    await compressFuncTable[format]({ requirePack, ...opt });
+    utils_1.SLogger.timeEnd(flag);
+}

package/dist/Command/CheckToken.d.ts

@@ -4,7 +4,7 @@ import type { Command } from "commander";
 export declare function checkNpmToken(opt?: {
     logstd?: boolean;
     threshold?: number;
-    loglvl?: LogLevel | 'none' | ((v: string) => void);
+    logLvl?: LogLevel | ((v: string) => void);
 }): Promise<string | undefined>;
 /**更新版本号并发布npm包 */
 export declare const CmdCheckToken: (program: Command) => Command;

package/dist/Command/CheckToken.js

@@ -5,7 +5,7 @@ exports.checkNpmToken = checkNpmToken;
 const utils_1 = require("@zwa73/utils");
 /**检查npm token过期 */
 async function checkNpmToken(opt) {
-    const { logstd = false, threshold = 15, loglvl = 'warn', } = opt ?? {};
+    const { logstd = false, threshold = 15, logLvl = 'warn', } = opt ?? {};
     try {
         const { stderr, stdout } = await utils_1.UtilFunc.exec('npm token list', {
             outlvl: logstd ? console.log : undefined
@@ -28,10 +28,10 @@ async function checkNpmToken(opt) {
         }
         const msgText = msg.join('\n');
         if (msgText.length > 0) {
-            if (typeof loglvl == 'string' && loglvl !== 'none')
-                utils_1.SLogger.log(loglvl, msgText);
-            else if (typeof loglvl == 'function')
-                loglvl(msgText);
+            if (typeof logLvl == 'string' && logLvl !== 'none')
+                utils_1.SLogger.log(logLvl, msgText);
+            else if (typeof logLvl == 'function')
+                logLvl(msgText);
             return msgText;
         }
         return undefined;

package/dist/Command/MapPath.js

@@ -17,7 +17,7 @@ const CmdMapPath = (program) => program
     .argument("<replacement>", "替换字符串")
     .option("-e, --exclude <regex>", "排除文件的正则表达式")
     .option(`-d, --duplicate-handling <${DupMethodList.join('|')}>`, `处理重名文件的方式:
-skip 不进行处理
+skip 不进行处理 默认
 overwrite 覆盖重名
 rename 以 [name]_idx[.ext?] 的形式重命名`, "skip")
     .option("-r, --recursive", "递归的处理子目录", false)

package/dist/Command/Release.js

@@ -30,7 +30,7 @@ const CmdRelease = (program) => program
     await (0, Bump_1.bump)(opt);
     utils_1.SLogger.info(`开始发布项目`);
     try {
-        const chkPromise = (0, CheckToken_1.checkNpmToken)({ loglvl: 'none' });
+        const chkPromise = (0, CheckToken_1.checkNpmToken)({ logLvl: 'none' });
         if (opt.local) {
             utils_1.SLogger.info("正在打包...");
             const fullpath = pathe_1.default.join(process.cwd(), opt.local);

package/dist/Command/Route.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cliRoute = cliRoute;
 const commander_1 = require("commander");
+const Archive_1 = require("./Archive");
 const Bump_1 = require("./Bump");
 const CheckToken_1 = require("./CheckToken");
 const ExpandMacro_1 = require("./ExpandMacro");
@@ -23,5 +24,6 @@ async function cliRoute() {
     (0, GenTemplate_1.CmdGenTemplate)(commander_1.program);
     (0, CheckToken_1.CmdCheckToken)(commander_1.program);
     (0, Bump_1.CmdBump)(commander_1.program);
+    (0, Archive_1.CmdArchive)(commander_1.program);
     commander_1.program.parse(process.argv);
 }

package/dist/Command/ScanDups.js

@@ -38,7 +38,7 @@ async function struct2hash(struct, fn) {
             return (await Promise.all(recursion(v))).flat();
         });
     };
-    return utils_1.UtilFunc.calcHash((await Promise.all(recursion(struct)))
+    return utils_1.UtilFunc.computeHash((await Promise.all(recursion(struct)))
         .flat().join('|'), { algorithm: "blake2b512" });
 }
 /**重命名文件或路径 scan_duplicates */
@@ -97,8 +97,8 @@ const CmdScanDups = (program) => program
         .map(async (filePath) => ({
         filePath,
         hash: struct
-            ? await struct2hash(await scanDirStruct(filePath), async (str) => utils_1.UtilFT.calculateHash(str, { sampled: true })).then(tap(() => sampledProgress.increment()))
-            : await utils_1.UtilFT.calculateHash(filePath, { sampled: true }).then(tap(() => sampledProgress.increment())),
+            ? await struct2hash(await scanDirStruct(filePath), async (str) => utils_1.UtilFT.computeHash(str, { sampled: true })).then(tap(() => sampledProgress.increment()))
+            : await utils_1.UtilFT.computeHash(filePath, { sampled: true }).then(tap(() => sampledProgress.increment())),
     }))
         .toArray(), 
     // 第三步：筛选重复的采样哈希 (去掉唯一的采样哈希)
@@ -109,8 +109,8 @@ const CmdScanDups = (program) => program
         .map(async (filePath) => ({
         filePath,
         hash: struct
-            ? await struct2hash(await scanDirStruct(filePath), async (str) => utils_1.UtilFT.calculateHash(str)).then(tap(() => sampledProgress.increment()))
-            : await utils_1.UtilFT.calculateHash(filePath).then(tap(() => fullHashProgress.increment())), // 计算完整哈希
+            ? await struct2hash(await scanDirStruct(filePath), async (str) => utils_1.UtilFT.computeHash(str)).then(tap(() => sampledProgress.increment()))
+            : await utils_1.UtilFT.computeHash(filePath).then(tap(() => fullHashProgress.increment())), // 计算完整哈希
     }))
         .toArray(), 
     // 第五步：重新整理完整哈希结果, 过滤唯一哈希

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/dev-utils",
-	"version": "1.0.94",
+	"version": "1.0.95",
 	"description": "编译与调试工具",
 	"main": "dist/index.js",
 	"scripts": {