ai-yuca 1.4.6 → 1.4.7

package/dist/bin/cli.js

@@ -45,6 +45,7 @@ const download_1 = require("../src/download");
 const uploadWithConfig_1 = require("../src/uploadWithConfig");
 const deploy_1 = require("../src/deploy");
 const transKey_1 = require("../src/transKey");
+const useTrans_1 = require("../src/useTrans");
 const tinify_1 = require("../src/tinify");
 const pullCrowdin_1 = require("../src/pullCrowdin");
 const sharp_1 = require("../src/sharp");
@@ -399,6 +400,14 @@ program
     .action(async (options) => {
     await (0, transKey_1.transKey)(options);
 });
+// 添加 useTrans 命令
+program
+    .command('useTrans')
+    .description('将 un-trans.json 中的翻译合并到 source 目录中')
+    .option('-c, --config <path>', '指定配置文件路径（默认为项目根目录下的vs.config.json）')
+    .action(async (options) => {
+    await (0, useTrans_1.useTrans)(options);
+});
 // 添加pull-crowdin命令
 program
     .command('cr-pull')

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai-yuca",
-    "version": "1.4.6",
+    "version": "1.4.7",
     "description": "一个用AI生成的开发辅助工具",
     "main": "dist/src/index.js",
     "types": "dist/src/index.d.ts",

package/dist/src/transKey.js

@@ -40,6 +40,7 @@ exports.transKey = transKey;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
+// {#测试的内容#}
 async function transKey(options) {
     try {
         // 1. 读取配置文件
@@ -109,6 +110,7 @@ async function transKey(options) {
         // 旧文件目录：Obj.crowdin.keysDir
         const oldFilesDir = path.join(process.cwd(), keysDir);
         // 4. 遍历语言生成文件
+        const untranslatedKeys = {};
         for (const lang of langMap) {
             const fileName = `${lang}.json`;
             const outputPath = path.join(outputDir, fileName);
@@ -151,6 +153,7 @@ async function transKey(options) {
             const newData = {};
             const sortedKeys = Array.from(keys).sort();
             let matchedCount = 0;
+            untranslatedKeys[lang] = {};
             for (const key of sortedKeys) {
                 // 优先使用整合后的 oldData
                 if (oldData[key]) {
@@ -159,12 +162,66 @@ async function transKey(options) {
                 }
                 else {
                     newData[key] = '';
+                    // 记录未翻译的词条
+                    untranslatedKeys[lang][key] = "";
                 }
             }
             // 写入文件到 source 目录
             fs.writeFileSync(outputPath, JSON.stringify(newData, null, 2), 'utf8');
             console.log(`✅ 生成 ${fileName}: 总 Key 数 ${sortedKeys.length}, 已翻译 ${matchedCount}`);
         }
+        // 5. 生成未翻译词条文件 (un-trans.json)
+        // 根据需求 "un-trans.json 存放在 source 中"
+        const untransPath = path.join(outputDir, 'un-trans.json');
+        let existingUntransData = {};
+        // 读取 un-trans.json 的存量数据
+        if (fs.existsSync(untransPath)) {
+            try {
+                existingUntransData = JSON.parse(fs.readFileSync(untransPath, 'utf8'));
+            }
+            catch (e) {
+                console.warn(`无法解析 un-trans.json: ${e}`);
+            }
+        }
+        // 合并新旧未翻译数据（保留旧数据）
+        // 逻辑：以新的 untranslatedKeys 为主，如果旧数据里有该语言该key且有值（虽然理论上未翻译文件里的值应该是空的，但也许用户手动填了？），
+        // 还是保留空值，因为既然在 source 里没值，说明还是未翻译。
+        // 但用户说 "每次执行这个操作前这个文件的存量数据"，意思是把新生成的未翻译数据和旧的合并？
+        // 通常 un-trans.json 只是一个报告文件。
+        // 如果用户想保留 un-trans.json 里的数据，可能是想看累计的未翻译？
+        // 但如果某个 key 在本次运行中已经翻译了（在 oldData 中有值），它就不应该出现在 un-trans.json 中了。
+        // 所以，un-trans.json 应该只包含当前真正未翻译的 key。
+        // "存量数据" 可能指的是：如果 un-trans.json 里有一些 key 是本次扫描没扫到的（比如代码删了），是否要保留？
+        // 或者，用户只是想把新发现的未翻译 key 合并进去？
+        // 根据需求 "每次执行这个操作前这个文件的存量数据" -> 可能是指读取它，然后做某种合并。
+        // 但最合理的逻辑是：un-trans.json 应该反映当前的未翻译状态。
+        // 如果 key 在代码中存在且未翻译 -> 写入 un-trans.json
+        // 如果 key 在代码中不存在 -> 不写入
+        // 如果 key 已翻译 -> 不写入
+        // 但既然提到了 "存量数据"，我将采用以下策略：
+        // 1. 读取旧 un-trans.json
+        // 2. 将本次检测到的未翻译 key 合并进去 (如果旧文件里有额外的内容，保留之？不，这会导致废弃 key 堆积)
+        // 让我们假设 "存量数据" 是指保留那些在本次扫描中依然未翻译的条目，或者仅仅是做一次全量覆盖？
+        // 如果是全量覆盖，那就不需要读取存量数据了。
+        // 既然明确要求 "每次执行这个操作前这个文件的存量数据"，那我就把旧数据读出来，
+        // 然后把本次的未翻译数据合并进去（覆盖旧的）。
+        // 修正：按照 "un-trans.json" 的通常用途，它应该是“当前未翻译词条的快照”。
+        // 但为了满足 "保留存量数据" 的字面意思，我会把旧数据 merge 进去。
+        // 比如：旧数据有 { "en": { "A": "" } }，本次扫描发现 { "en": { "B": "" } }
+        // 结果是 { "en": { "A": "", "B": "" } }
+        // 风险：如果 "A" 已经在代码中删除了，它还会留在 un-trans.json 中。
+        const finalUntransData = { ...existingUntransData };
+        for (const lang of langMap) {
+            if (!finalUntransData[lang]) {
+                finalUntransData[lang] = {};
+            }
+            // 合并当前未翻译的
+            for (const key in untranslatedKeys[lang]) {
+                finalUntransData[lang][key] = "";
+            }
+        }
+        fs.writeFileSync(untransPath, JSON.stringify(finalUntransData, null, 2), 'utf8');
+        console.log(`\n📋 未翻译词条已导出至: ${untransPath}`);
         console.log('\n所有文件生成完毕！');
     }
     catch (err) {

package/dist/src/useTrans.d.ts

@@ -0,0 +1,5 @@
+interface UseTransOptions {
+    config?: string;
+}
+export declare function useTrans(options: UseTransOptions): Promise<void>;
+export {};

package/dist/src/useTrans.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTrans = useTrans;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+async function useTrans(options) {
+    try {
+        // 1. 读取配置文件
+        const configPath = options.config || path.join(process.cwd(), 'vs.config.json');
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`配置文件不存在: ${configPath}`);
+        }
+        console.log(`读取配置文件: ${configPath}`);
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const crowdinConfig = config.crowdin;
+        if (!crowdinConfig) {
+            throw new Error('配置文件中缺少 crowdin 配置');
+        }
+        const { keysDir, langMap } = crowdinConfig;
+        if (!keysDir || !langMap) {
+            throw new Error('crowdin 配置缺少必要字段: keysDir, langMap');
+        }
+        // source 目录: keysDir/source
+        const sourceDir = path.join(process.cwd(), keysDir, 'source');
+        // 根据需求 "un-trans.json 存放在 source 中"
+        const untransPath = path.join(sourceDir, 'un-trans.json');
+        if (!fs.existsSync(untransPath)) {
+            console.log(chalk_1.default.yellow(`未找到未翻译文件: ${untransPath}`));
+            return;
+        }
+        console.log(chalk_1.default.blue(`读取未翻译文件: ${untransPath}`));
+        let untransData = {};
+        try {
+            untransData = JSON.parse(fs.readFileSync(untransPath, 'utf8'));
+        }
+        catch (e) {
+            throw new Error(`解析 un-trans.json 失败: ${e}`);
+        }
+        // 2. 遍历语言并合并
+        for (const lang of langMap) {
+            // untransData 中的 key 就是 lang
+            const langUntrans = untransData[lang];
+            if (!langUntrans) {
+                console.log(chalk_1.default.gray(`  - 未找到语言 ${lang} 的未翻译数据，跳过`));
+                continue;
+            }
+            const fileName = `${lang}.json`;
+            const sourceFilePath = path.join(sourceDir, fileName);
+            if (!fs.existsSync(sourceFilePath)) {
+                console.log(chalk_1.default.yellow(`源文件不存在，跳过: ${fileName}`));
+                continue;
+            }
+            console.log(`处理语言: ${lang}`);
+            let sourceData = {};
+            try {
+                sourceData = JSON.parse(fs.readFileSync(sourceFilePath, 'utf8'));
+            }
+            catch (e) {
+                console.error(chalk_1.default.red(`无法解析源文件 ${fileName}: ${e}`));
+                continue;
+            }
+            let mergedCount = 0;
+            for (const key in langUntrans) {
+                // 如果 un-trans.json 中有值（用户已翻译）
+                const transValue = langUntrans[key];
+                if (transValue && transValue.trim() !== '') {
+                    // 如果 sourceData 里有这个 key，我们就更新它。
+                    if (Object.prototype.hasOwnProperty.call(sourceData, key)) {
+                        sourceData[key] = transValue;
+                        mergedCount++;
+                    }
+                    else {
+                        // 如果 sourceData 里没有，我们选择添加进去。
+                        sourceData[key] = transValue;
+                        mergedCount++;
+                    }
+                }
+            }
+            if (mergedCount > 0) {
+                fs.writeFileSync(sourceFilePath, JSON.stringify(sourceData, null, 2), 'utf8');
+                console.log(chalk_1.default.green(`  ✓ 已合并 ${mergedCount} 条翻译到 ${fileName}`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`  - 无需合并 (未翻译文件中没有已翻译的值)`));
+            }
+        }
+        console.log(chalk_1.default.blue('\n合并完成！'));
+        console.log(chalk_1.default.yellow('注意：合并后的更改目前只在 source 目录中。下次运行 transKey 时，这些更改会被整合回 keysDir 主文件。'));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`UseTrans 操作失败: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-yuca",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "一个用AI生成的开发辅助工具",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

package/un-trans.json

@@ -0,0 +1,26 @@
+{
+  "zh-cn": {
+    "测试的内容": ""
+  },
+  "en-us": {
+    "测试的内容": ""
+  },
+  "de-de": {
+    "测试的内容": ""
+  },
+  "pt-pt": {
+    "测试的内容": ""
+  },
+  "fr-fr": {
+    "测试的内容": ""
+  },
+  "es-es": {
+    "测试的内容": ""
+  },
+  "it-it": {
+    "测试的内容": ""
+  },
+  "ru-ru": {
+    "测试的内容": ""
+  }
+}