scancscode 1.0.42 → 1.0.46

package/bin/scanliterals.js

@@ -1,3 +1,3 @@
-#!/usr/bin/env node
-
-require("../dist/src/RunConvert.js")
+#!/usr/bin/env node
+
+require("../dist/src/RunConvert.js")

package/bin/slimlangs.js

@@ -1,3 +1,3 @@
-#!/usr/bin/env node
-
-require("../dist/src/RunSlimLangs.js")
+#!/usr/bin/env node
+
+require("../dist/src/RunSlimLangs.js")

package/bin/translatecsvfile.js

@@ -1,3 +1,3 @@
-#!/usr/bin/env node
-
-require("../dist/src/RunTranslateCSV.js")
+#!/usr/bin/env node
+
+require("../dist/src/RunTranslateCSV.js")

package/dist/src/CmdExecutor.js

@@ -123,7 +123,7 @@ class CmdExecutor {
         let toLangs = options.toLangs ?? undefined;
         let apiKey = options.apiKey;
         let appId = options.appId;
-        console.log(`slim csv cmd options: `, incsv, outcsv, fromLang, toLangs);
+        console.log(`translate csv cmd options: `, incsv, outcsv, fromLang, toLangs, apiKey, appId);
         let argv = process.argv;
         if (incsv == null) {
             console.error(`incsv missing:`, argv);
@@ -149,7 +149,7 @@ class CmdExecutor {
             console.error(`appId missing:`, argv);
             return;
         }
-        await CsvAutoTranslator_1.CsvAutoTranslator.translateCsvWithLangs(incsv, outcsv, fromLang, toLangs, apiKey, appId);
+        await CsvAutoTranslator_1.CsvAutoTranslator.translateCsvWithLangs(appId, apiKey, incsv, outcsv, fromLang, toLangs);
         console.log("translate csv with cmd options done.");
     }
 }

package/dist/src/CsvAutoTranslator.js

@@ -37,6 +37,31 @@ exports.CsvAutoTranslator = void 0;
 const crypto = __importStar(require("crypto"));
 const https = __importStar(require("https"));
 const CSVUtils_1 = require("./CSVUtils");
+class OnlineTranslateResult {
+    errorCode = "";
+    errorMsg = "";
+    isOk = false;
+    translatedTexts;
+    constructor(errorCode, errorMsg, isOk, translatedTexts) {
+        this.errorCode = errorCode;
+        this.errorMsg = errorMsg;
+        this.isOk = isOk;
+        this.translatedTexts = translatedTexts;
+    }
+}
+class TranslateCSVResult {
+    translateCount = 0;
+    isOk = false;
+    firstErrorCode = "";
+    firstErrorMsg = "";
+    constructor(translateCount, isOk, firstErrorCode, firstErrorMsg) {
+        this.translateCount = translateCount;
+        this.isOk = isOk;
+        this.firstErrorCode = firstErrorCode;
+        this.firstErrorMsg = firstErrorMsg;
+    }
+    static Empty = new TranslateCSVResult(0, false, "", "");
+}
 class CsvAutoTranslator {
     apiKey;
     appId;
@@ -44,7 +69,7 @@ class CsvAutoTranslator {
     maxBatchSize = 5;
     MAX_BATCH_TEXT_COUNT = 50;
     MAX_BATCH_JSON_SIZE = 4900;
-    constructor(apiKey, appId) {
+    constructor(appId, apiKey) {
         this.apiKey = apiKey;
         this.appId = appId;
     }
@@ -107,9 +132,14 @@ class CsvAutoTranslator {
     async translateBatch(texts, from, to) {
         const response = await this.requestTranslate(texts, from, to);
         if (response.resultCode !== "200") {
-            throw new Error(`翻译失败: ${response.resultMsg}`);
+            let errTip = `翻译失败: ${response.errorCode}, ${response.errorMsg}, ${response.resultCode}, ${response.resultMsg}`;
+            console.error(errTip);
+            console.error("翻译失败内容:", texts);
+            let result = new OnlineTranslateResult(response.errorCode, response.errorMsg, false, new Array(texts.length).fill(""));
+            return result;
         }
-        return response.tgtList.map(item => item.tgtText || "");
+        let result = new OnlineTranslateResult(response.resultCode, response.resultMsg, true, response.tgtList.map(item => item.tgtText || ""));
+        return result;
     }
     estimateSingleTextJsonSize(text, isSingle) {
         return Buffer.byteLength(JSON.stringify(text)) + (isSingle ? 0 : 1);
@@ -159,18 +189,28 @@ class CsvAutoTranslator {
         const results = new Array(batches.length);
         const concurrencyLimit = this.maxBatchSize;
         let index = 0;
+        let isOk = true;
         let batchCount = 0;
+        let firstErrorCode = "";
+        let firstErrorMsg = "";
         const processBatch = async () => {
             while (index < batches.length) {
                 const batchIndex = index++;
                 const batch = batches[batchIndex];
                 batchCount++;
                 console.log(`batchCount++: ${batchCount}`);
-                const batchResults = await this.translateBatch(batch, from, to);
+                const batchResult = await this.translateBatch(batch, from, to);
+                if (!batchResult.isOk) {
+                    isOk = false;
+                    if (firstErrorCode === "") {
+                        firstErrorCode = batchResult.errorCode;
+                        firstErrorMsg = batchResult.errorMsg;
+                    }
+                }
                 await new Promise(resolve => setTimeout(resolve, 1000));
                 batchCount--;
                 console.log(`batchCount--: ${batchCount}`);
-                results[batchIndex] = batchResults;
+                results[batchIndex] = batchResult.translatedTexts;
             }
         };
         const workers = [];
@@ -179,7 +219,9 @@ class CsvAutoTranslator {
         }
         await Promise.all(workers);
         // await processBatch()
-        return results.flat();
+        let translatedTexts = results.flat();
+        let result = new OnlineTranslateResult(firstErrorCode, firstErrorMsg, isOk, translatedTexts);
+        return result;
     }
     langMap = new Map([
         ["zh_cn", "zh"],
@@ -189,45 +231,27 @@ class CsvAutoTranslator {
     async translateCsvRows(rows, fromLang, toLangs) {
         if (rows.length === 0) {
             console.log("CSV文件为空");
-            return 0;
+            return TranslateCSVResult.Empty;
         }
         let header = rows[0];
         let fromLangIndex = header.indexOf(fromLang);
         if (fromLangIndex === -1) {
             console.error(`未找到 ${fromLang} 列`);
-            return 0;
+            return TranslateCSVResult.Empty;
         }
         if (!this.langMap.has(fromLang)) {
             console.error(`未找到 ${fromLang} 的目标语言`);
-            return 0;
+            return TranslateCSVResult.Empty;
         }
         let fromLang2 = this.langMap.get(fromLang);
         if (fromLang2 == null) {
             console.error(`未找到 ${fromLang} 的目标语言`);
-            return 0;
+            return TranslateCSVResult.Empty;
         }
-        const needTranslateIndices = [];
-        const needTranslateTexts = [];
-        for (let i = 1; i < rows.length; i++) {
-            const row = rows[i];
-            if (!row[0] || row[0].trim() === "") {
-                continue;
-            }
-            if (row[fromLangIndex] && row[fromLangIndex].trim() !== "") {
-                continue;
-            }
-            needTranslateIndices.push(i);
-            let text = row[fromLangIndex];
-            if (text == null || text == "") {
-                text = row[0];
-            }
-            needTranslateTexts.push(text);
-        }
-        if (needTranslateTexts.length === 0) {
-            console.log("没有需要翻译的内容");
-            return 0;
-        }
-        console.log(`开始翻译 ${needTranslateTexts.length} 条内容...`);
+        let isOk = true;
+        let translateCount = 0;
+        let firstErrorCode = "";
+        let firstErrorMsg = "";
         for (let curLangIndex = 0; curLangIndex < header.length; curLangIndex++) {
             let lang = header[curLangIndex];
             lang = lang.trim().toLowerCase();
@@ -237,36 +261,79 @@ class CsvAutoTranslator {
             if (toLangs != undefined && !toLangs.includes(lang)) {
                 continue;
             }
-            if (lang != fromLang && this.langMap.has(lang)) {
-                const toLang = this.langMap.get(lang);
-                if (toLang == null) {
-                    console.error(`未找到 ${lang} 的目标语言`);
+            if (!(lang != fromLang && this.langMap.has(lang))) {
+                continue;
+            }
+            const needTranslateIndices = [];
+            const needTranslateTexts = [];
+            for (let i = 1; i < rows.length; i++) {
+                const row = rows[i];
+                if (!row[0] || row[0].trim() === "") {
                     continue;
                 }
-                const translations = await this.translateAll(needTranslateTexts, fromLang2, toLang);
-                for (let j = 0; j < needTranslateIndices.length; j++) {
-                    const rowIndex = needTranslateIndices[j];
-                    while (rows[rowIndex].length < header.length) {
-                        rows[rowIndex].push("");
-                    }
-                    rows[rowIndex][curLangIndex] = translations[j];
+                if (row[curLangIndex] && row[curLangIndex].trim() !== "") {
+                    continue;
+                }
+                let text = row[fromLangIndex];
+                if (text == null || text == "") {
+                    text = row[0];
+                }
+                if (text == null || text === "") {
+                    continue;
+                }
+                needTranslateIndices.push(i);
+                needTranslateTexts.push(text);
+            }
+            if (needTranslateTexts.length === 0) {
+                console.log("没有需要翻译的内容");
+                return TranslateCSVResult.Empty;
+            }
+            console.log(`开始翻译 ${needTranslateTexts.length} 条内容...`);
+            const toLang = this.langMap.get(lang);
+            if (toLang == null) {
+                console.error(`未找到 ${lang} 的目标语言`);
+                continue;
+            }
+            const translateResult = await this.translateAll(needTranslateTexts, fromLang2, toLang);
+            isOk = isOk && translateResult.isOk;
+            if (!translateResult.isOk) {
+                if (firstErrorCode === "") {
+                    firstErrorCode = translateResult.errorCode;
+                    firstErrorMsg = translateResult.errorMsg;
+                }
+                console.error(`翻译 ${lang} 失败: ${translateResult.errorCode} ${translateResult.errorMsg}`);
+                continue;
+            }
+            let translations = translateResult.translatedTexts;
+            for (let j = 0; j < needTranslateIndices.length; j++) {
+                const rowIndex = needTranslateIndices[j];
+                while (rows[rowIndex].length < header.length) {
+                    rows[rowIndex].push("");
                 }
+                rows[rowIndex][curLangIndex] = translations[j];
             }
+            translateCount += needTranslateTexts.length;
         }
-        return needTranslateTexts.length;
+        let result = new TranslateCSVResult(translateCount, isOk, firstErrorCode, firstErrorMsg);
+        return result;
     }
     async translateCsv(filePath, outFilePath, fromLang = "auto", toLangs) {
         const csvUtils = new CSVUtils_1.CSVUtils(filePath);
         const rows = await csvUtils.parseCsv();
-        const translatedCount = await this.translateCsvRows(rows, fromLang, toLangs);
-        if (translatedCount > 0) {
+        const translatedResult = await this.translateCsvRows(rows, fromLang, toLangs);
+        if (translatedResult.isOk && translatedResult.translateCount > 0) {
             await CSVUtils_1.CSVUtils.writeCsv(outFilePath, rows);
-            console.log(`翻译完成，已更新 ${translatedCount} 条内容到 ${outFilePath}`);
+            console.log(`翻译完成，已更新 ${translatedResult.translateCount} 条内容到 ${outFilePath}`);
         }
+        else {
+            console.log(`翻译完成，未更新任何内容到 ${outFilePath}`);
+        }
+        return translatedResult;
     }
-    static async translateCsvWithLangs(filePath, outFilePath, fromLang, langs, apiKey, appId) {
-        const translator = new CsvAutoTranslator(apiKey, appId);
-        await translator.translateCsv(filePath, outFilePath, fromLang, langs);
+    static async translateCsvWithLangs(appId, apiKey, filePath, outFilePath, fromLang, langs) {
+        const translator = new CsvAutoTranslator(appId, apiKey);
+        let result = await translator.translateCsv(filePath, outFilePath, fromLang, langs);
+        return result;
     }
 }
 exports.CsvAutoTranslator = CsvAutoTranslator;

package/dist/test/CsvAutoTranslator.test.js

@@ -27,7 +27,7 @@ describe("CsvAutoTranslator", () => {
             expect(true).toBe(true);
             return;
         }
-        const translator = new CsvAutoTranslator_1.CsvAutoTranslator(apiKey, appId);
+        const translator = new CsvAutoTranslator_1.CsvAutoTranslator(appId, apiKey);
         const rows = JSON.parse(JSON.stringify(testRows));
         const translatedCount = await translator.translateCsvRows(rows, "zh_cn");
         expect(translatedCount).toBe(10);
@@ -45,7 +45,7 @@ describe("CsvAutoTranslator", () => {
             expect(true).toBe(true);
             return;
         }
-        const translator = new CsvAutoTranslator_1.CsvAutoTranslator(apiKey, appId);
+        const translator = new CsvAutoTranslator_1.CsvAutoTranslator(appId, apiKey);
         const rows = JSON.parse(JSON.stringify(testRows));
         rows[1][2] = "已有译文";
         const translatedCount = await translator.translateCsvRows(rows, "zh_cn");
@@ -53,12 +53,12 @@ describe("CsvAutoTranslator", () => {
         expect(rows[10][2]).toBe("歡迎來到中國");
     }, 120000);
     test("translateCsvRows - 空CSV测试", async () => {
-        const translator = new CsvAutoTranslator_1.CsvAutoTranslator("dummy-key", "dummy-id");
+        const translator = new CsvAutoTranslator_1.CsvAutoTranslator(NIUTRANS_APP_ID, NIUTRANS_API_KEY);
         const translatedCount = await translator.translateCsvRows([], "zh_cn");
         expect(translatedCount).toBe(0);
     });
     test("translateCsvRows - 没有需要翻译的内容", async () => {
-        const translator = new CsvAutoTranslator_1.CsvAutoTranslator("dummy-key", "dummy-id");
+        const translator = new CsvAutoTranslator_1.CsvAutoTranslator(NIUTRANS_APP_ID, NIUTRANS_API_KEY);
         const rows = [
             ["key", "en_us", "zh_hk"],
             ["Hello", "", "已有译文1"],
@@ -68,7 +68,7 @@ describe("CsvAutoTranslator", () => {
         expect(translatedCount).toBe(0);
     });
     describe("smartBatch - 边界回归测试", () => {
-        const translator = new CsvAutoTranslator_1.CsvAutoTranslator("dummy-key", "dummy-id");
+        const translator = new CsvAutoTranslator_1.CsvAutoTranslator(NIUTRANS_APP_ID, NIUTRANS_API_KEY);
         test("空文本数组", () => {
             const batches = translator.smartBatch([]);
             expect(batches.length).toBe(0);
@@ -157,4 +157,14 @@ describe("CsvAutoTranslator", () => {
             }
         }, 300000);
     });
+    describe("translateCSV", () => {
+        test("翻译 Auto.csv 并验证输出", async () => {
+            const incsv = "test/Auto.csv";
+            const outcsv = "temp/Auto-Out.csv";
+            const fromLang = "zh_cn";
+            let result = await CsvAutoTranslator_1.CsvAutoTranslator.translateCsvWithLangs("kDr1772519780125", "4cfb5525d3be1e45003910059cd7ea9b", incsv, outcsv, fromLang);
+            expect(result.isOk).toBe(true);
+            expect(result.translateCount).toBeGreaterThan(0);
+        });
+    });
 });

package/docs/CSharpStringExtractor/344/273/243/347/240/201/347/224/237/346/210/220/346/217/220/347/244/272/350/257/215.txt

@@ -1,73 +1,73 @@
-对文件进行TypeScript代码重构，重点优化字符串匹配方法设计，将原有的整句C#语句捕获逻辑精确调整为仅捕获字符串值表达式部分，通过90%的测试用例。开发过程中必须严格遵循以下规范：采用原生TypeScript开发方式，严禁使用反编译JavaScript的方法；禁止使用`git show`等需要用户手动确认的操作；所有中间生成的临时文件仅在最终结束时，以清单形式提示用户需要清理的文件列表，不得自动执行清理操作。不要使用 `<`、 `&`、`>` 等html代码中才有的符号，严格使用 typescript 语言语法, 不使用 `arguments` 等保留字段作为局部变量名。
-其中CodeSnippet类成员定义如下:
-
-```typescript
-export class CodeSnippet {
-    /**
-     * 要替换的原始内容在代码全文中的起始位置，从0开始
-     */
-    originalIndex: number;
-    /**
-     * 从originalIndex开始长度至少30个字符的原始代码文本,如果从originalIndex开始后续全文中包含`;`符号,那么originalContext必须包含一个`;`号
-     */
-    originalContext: string;
-    /**
-     * 标记是否改变了原始代码内容，如果需要替换文件内容则为true，否则为false; 具体定义为: isChanged = originalCode!=convertedCode
-     */
-    isChanged: boolean;
-    /**
-     * 要替换的C#语句整句原始内容
-     */
-    originalCode: string;
-    /**
-     * originalCode转换后的代码
-     */
-    convertedCode: string;
-    /**
-     * 匹配出的所有字符串列表, 包括转换出来的字符串模板，同一个位置匹配出的字符串会合并到一个元素中
-     */
-    literals: string[];
-    /**
-     * 无法识别的疑似字符串列表
-     */
-    unexpects: string[];
-}
-```
-
-
-代码实现需满足以下具体技术要求：
-1. 重构originalCode的解析逻辑，实现精确的字符串操作表达式定位与提取，严格排除非字符串表达式的代码部分
-2. 基于调整后的originalCode提取逻辑，同步更新convertedCode的转换逻辑和originalIndex的位置映射关系，确保代码转换的准确性和位置对应关系
-3. 完整实现CSharpStringExtractor类，该类必须包含名为`extractStrings`的公共成员方法。此方法接收C#代码字符串作为输入参数，提取其中的字符串文本转换信息，并以CodeSnippet[]数组形式返回处理结果
-
-CodeSnippet数据结构必须严格符合以下规范：
-- CodeSnippet.originalCode：存储从C#代码中提取的完整字符串值表达式文本，确保不包含多余的代码内容
-- CodeSnippet.convertedCode：存储按照"规则A"转换后的字符串值表达式文本，保持语法正确性
-- CodeSnippet.literals：存储从字符串值表达式中提取的所有字符串文本组成的字符串数组，确保包含所有嵌套和连接的字符串片段，包括转义字符和特殊符号
-
-"规则A"转换逻辑的详细实现规范：
-1. 对于赋值表达式中形如`xxx.text = 字符串值表达式`的模式：
-   - 非内插字符串（不以$@或$开头）：在原始字符串值表达式末尾添加`.TR()`方法调用，保持原有字符串内容不变
-   - 内插字符串（以$@或$开头）：将整个字符串表达式转换为`Tr.Format(...)`格式，保持原有占位符结构和表达式逻辑
-2. 对于使用`+`运算符连接的字符串表达式：
-   - 对每个独立的字符串子表达式应用与规则1相同的转换处理，保持原有的连接结构和运算顺序
-3. 其他所有不符合上述模式的情况：
-   - CodeSnippet.convertedCode字段保持原始字符串值表达式不变
-   - CodeSnippet.literals字段仍需准确提取所有字符串文本内容，包括转义字符和特殊符号
-4. string.Format(...) 形式包含的字符串表达式, 需要特殊处理, 连带 `string.Format()` 一起捕获存入 originalCode 成员
-5. 需要捕获类对象成员初始化赋值表达式中, 出现在赋值操作符`=`右侧的字符串值表达式
-6. 需要能捕获 switch 语句中包含普通字符串的情况
-7. 需要正确识别字符串包含各种特殊符号和转译符号组合的情况, 能正确识别这种情况下的字符串边界
-8. 函数参数需要拆分, 逐个参数捕获
-9. string.Format(...) 形式包含的字符串表达式, 需要特殊处理, 连带 `string.Format()` 一起捕获存入 originalCode 成员
-
-
-
-实现过程中必须特别注意以下技术要点：
-- 实现精确的字符串边界识别算法，正确处理单引号和双引号字符串的开始与结束位置
-- 设计转义字符处理机制，妥善处理字符串中的转义字符（如\"、\'、\\等），避免错误识别字符串边界
-- 开发代码结构分析逻辑，正确区分字符串内的代码内容与字符串外的代码结构
-- 确保提取的字符串文本的准确性和完整性，包括多行字符串、复杂嵌套结构和特殊编码字符
-- 全面处理各种边缘情况，如空字符串、仅包含空格的字符串、包含特殊字符的字符串、零长度字符串等
-
+对文件进行TypeScript代码重构，重点优化字符串匹配方法设计，将原有的整句C#语句捕获逻辑精确调整为仅捕获字符串值表达式部分，通过90%的测试用例。开发过程中必须严格遵循以下规范：采用原生TypeScript开发方式，严禁使用反编译JavaScript的方法；禁止使用`git show`等需要用户手动确认的操作；所有中间生成的临时文件仅在最终结束时，以清单形式提示用户需要清理的文件列表，不得自动执行清理操作。不要使用 `<`、 `&`、`>` 等html代码中才有的符号，严格使用 typescript 语言语法, 不使用 `arguments` 等保留字段作为局部变量名。
+其中CodeSnippet类成员定义如下:
+
+```typescript
+export class CodeSnippet {
+    /**
+     * 要替换的原始内容在代码全文中的起始位置，从0开始
+     */
+    originalIndex: number;
+    /**
+     * 从originalIndex开始长度至少30个字符的原始代码文本,如果从originalIndex开始后续全文中包含`;`符号,那么originalContext必须包含一个`;`号
+     */
+    originalContext: string;
+    /**
+     * 标记是否改变了原始代码内容，如果需要替换文件内容则为true，否则为false; 具体定义为: isChanged = originalCode!=convertedCode
+     */
+    isChanged: boolean;
+    /**
+     * 要替换的C#语句整句原始内容
+     */
+    originalCode: string;
+    /**
+     * originalCode转换后的代码
+     */
+    convertedCode: string;
+    /**
+     * 匹配出的所有字符串列表, 包括转换出来的字符串模板，同一个位置匹配出的字符串会合并到一个元素中
+     */
+    literals: string[];
+    /**
+     * 无法识别的疑似字符串列表
+     */
+    unexpects: string[];
+}
+```
+
+
+代码实现需满足以下具体技术要求：
+1. 重构originalCode的解析逻辑，实现精确的字符串操作表达式定位与提取，严格排除非字符串表达式的代码部分
+2. 基于调整后的originalCode提取逻辑，同步更新convertedCode的转换逻辑和originalIndex的位置映射关系，确保代码转换的准确性和位置对应关系
+3. 完整实现CSharpStringExtractor类，该类必须包含名为`extractStrings`的公共成员方法。此方法接收C#代码字符串作为输入参数，提取其中的字符串文本转换信息，并以CodeSnippet[]数组形式返回处理结果
+
+CodeSnippet数据结构必须严格符合以下规范：
+- CodeSnippet.originalCode：存储从C#代码中提取的完整字符串值表达式文本，确保不包含多余的代码内容
+- CodeSnippet.convertedCode：存储按照"规则A"转换后的字符串值表达式文本，保持语法正确性
+- CodeSnippet.literals：存储从字符串值表达式中提取的所有字符串文本组成的字符串数组，确保包含所有嵌套和连接的字符串片段，包括转义字符和特殊符号
+
+"规则A"转换逻辑的详细实现规范：
+1. 对于赋值表达式中形如`xxx.text = 字符串值表达式`的模式：
+   - 非内插字符串（不以$@或$开头）：在原始字符串值表达式末尾添加`.TR()`方法调用，保持原有字符串内容不变
+   - 内插字符串（以$@或$开头）：将整个字符串表达式转换为`Tr.Format(...)`格式，保持原有占位符结构和表达式逻辑
+2. 对于使用`+`运算符连接的字符串表达式：
+   - 对每个独立的字符串子表达式应用与规则1相同的转换处理，保持原有的连接结构和运算顺序
+3. 其他所有不符合上述模式的情况：
+   - CodeSnippet.convertedCode字段保持原始字符串值表达式不变
+   - CodeSnippet.literals字段仍需准确提取所有字符串文本内容，包括转义字符和特殊符号
+4. string.Format(...) 形式包含的字符串表达式, 需要特殊处理, 连带 `string.Format()` 一起捕获存入 originalCode 成员
+5. 需要捕获类对象成员初始化赋值表达式中, 出现在赋值操作符`=`右侧的字符串值表达式
+6. 需要能捕获 switch 语句中包含普通字符串的情况
+7. 需要正确识别字符串包含各种特殊符号和转译符号组合的情况, 能正确识别这种情况下的字符串边界
+8. 函数参数需要拆分, 逐个参数捕获
+9. string.Format(...) 形式包含的字符串表达式, 需要特殊处理, 连带 `string.Format()` 一起捕获存入 originalCode 成员
+
+
+
+实现过程中必须特别注意以下技术要点：
+- 实现精确的字符串边界识别算法，正确处理单引号和双引号字符串的开始与结束位置
+- 设计转义字符处理机制，妥善处理字符串中的转义字符（如\"、\'、\\等），避免错误识别字符串边界
+- 开发代码结构分析逻辑，正确区分字符串内的代码内容与字符串外的代码结构
+- 确保提取的字符串文本的准确性和完整性，包括多行字符串、复杂嵌套结构和特殊编码字符
+- 全面处理各种边缘情况，如空字符串、仅包含空格的字符串、包含特殊字符的字符串、零长度字符串等
+
 完成实现后，需进行全面测试验证：确保代码通过90%以上的测试用例，对未通过的测试用例进行针对性分析和优化，提供详细的测试报告和优化方案。

package/jest.config.js

@@ -1,9 +1,9 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
-  moduleFileExtensions: ['ts', 'js'],
-  transform: {
-    '^.+\.ts$': 'ts-jest'
-  }
-};
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+  moduleFileExtensions: ['ts', 'js'],
+  transform: {
+    '^.+\.ts$': 'ts-jest'
+  }
+};

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "scancscode",
-  "version": "1.0.42",
+  "version": "1.0.46",
   "description": "",
   "main": "./dist/index.js",
   "bin": {
     "scanliterals": "bin/scanliterals.js",
-    "slimlangs": "bin/slimlangs.js"
+    "slimlangs": "bin/slimlangs.js",
+    "translatecsvfile": "bin/translatecsvfile.js"
   },
   "scripts": {
     "scanliterals":"node bin/scanliterals.js",
     "slimlangs":"node bin/slimlangs.js",
+    "translatecsvfile": "node bin/translatecsvfile.js",
     "test": "jest"
   },
   "keywords": [],

package/src/CmdExecutor.ts

@@ -124,7 +124,7 @@ export class CmdExecutor {
         let apiKey: string = options.apiKey;
         let appId: string = options.appId;
 
-        console.log(`slim csv cmd options: `, incsv, outcsv, fromLang, toLangs);
+        console.log(`translate csv cmd options: `, incsv, outcsv, fromLang, toLangs, apiKey, appId);
         let argv = process.argv;
         if (incsv == null) {
             console.error(`incsv missing:`, argv);
@@ -149,8 +149,8 @@ export class CmdExecutor {
         if (appId == null) {
             console.error(`appId missing:`, argv);
             return;
-        }
-        await CsvAutoTranslator.translateCsvWithLangs(incsv, outcsv, fromLang, toLangs, apiKey, appId);
+            }
+            await CsvAutoTranslator.translateCsvWithLangs(appId, apiKey, incsv, outcsv, fromLang, toLangs);
         console.log("translate csv with cmd options done.");
     }
 }