scancscode 1.0.29 → 1.0.30

package/dist/src/CSCodeScanner.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSCodeScanner = void 0;
+const CSharpStringExtractor_1 = require("./CSharpStringExtractor");
+const LiteralCollector_1 = require("./LiteralCollector");
+/**
+ * 扫描C#代码, 扫描出其中所有形如 uictrl.text = 其他内容; 的代码片段, 其他内容可以是: $"<font color={colorStr}>{itemConfig.Name}</ font>"; 等等, 其他内容中形如 {变量} 的部分需要提取出来, 转换成 string.Format("<font color={0}>{1}</ font>", colorStr, itemConfig.Name); 的格式
+ */
+class CSCodeScanner {
+    // 正则表达式匹配 uictrl.text = $"..."; 的模式
+    static assignmentPattern = /([\w\.\u4e00-\u9fff]+\.text\s*\+?=(?![=>])\s*|return\s+)([^;]+)\s*;/mg;
+    // 正则表达式匹配 xxx = "..."; 的模式
+    static assignmentPattern2 = /(^\s*[\.a-zA-Z0-9_\u4e00-\u9fff]+\s*\+?=)\s*;/mg;
+    // 正则表达式匹配 匹配每个字符串
+    static stringPattern = /\$?"([^"]*)"/mg;
+    // 正则表达式匹配 匹配获取成员值的表达式
+    static getMemberValuePattern(trMethodName) {
+        return new RegExp(`^(\\s*)([\\w\\.\\u4e00-\\u9fff\\[\\]]+)(\\.${trMethodName}\\(\\))?(\\s*)$`, "m");
+    }
+    static memberSplit = /^[\s\+;]/;
+    // 正则表达式匹配插值表达式 {...}
+    static interpolationPattern = /\{([^}]+?)(\:[a-zA-Z\d-\.\#(?:\\\\:)\u4e00-\u9fff]+)?\}/mg;
+    static stringFormatPattern = /(?<![a-zA-Z_\u4e00-\u9fff])([sS]tring\.Format)(?=\(.*?\))/mg;
+    static interpolationHeadPattern = /^[\$\@]*(.+)$/m;
+    static isNativeString2(s) {
+        return s == '""';
+    }
+    static isNativeString(s) {
+        let m = s.match(this.interpolationHeadPattern);
+        if (m != null) {
+            let stringContent = m[1];
+            return this.isNativeString2(stringContent);
+        }
+        return this.isNativeString2(s);
+    }
+    static getLineIndexFromIndex(content, index) {
+        let lineIndex = 0;
+        // 从第0个字符开始遍历到index位置, 计算换行符数量
+        for (let i = 0; i < index && i < content.length; i++) {
+            if (content[i] === '\n') {
+                lineIndex++;
+            }
+        }
+        let lineColumn = content.lastIndexOf('\n', index);
+        return [lineIndex + 1, index - lineColumn];
+    }
+    static scanFile(filePath, content, trmethod) {
+        let trmethodParts = trmethod.split(".");
+        let trclassname = "Tr";
+        let trmethodname = "TR";
+        if (trmethodParts.length == 2) {
+            trclassname = trmethodParts[0];
+            trmethodname = trmethodParts[1];
+        }
+        const snippets = [];
+        // const assignMatches = [...content.matchAll(CSCodeScanner.assignmentPattern)];
+        // for (let j = 0; j < assignMatches.length; j++) {
+        //     const assignMatch = assignMatches[j];
+        //     // let assignLine = assignMatch[0];
+        //     // let assignHead = assignMatch[1];
+        //     // let bodyLine = assignMatch[2];
+        //     let [assignLine, assignHead, bodyLine] = assignMatch;
+        //     let convertedAssignLine: string;
+        //     /**
+        //      * 需要翻译的文本
+        //      */
+        //     let literals: string[] = [];
+        //     let unexpects: string[] = [];
+        //     const stringMatchs = [...bodyLine.matchAll(CSCodeScanner.stringPattern)];
+        //     if (stringMatchs.length > 0) {
+        //         // 通过是否单行字符串并以 ".TR(); 结尾和判断是否内插字符串来判断是否需要在结尾附加 .TR()
+        //         let isSingleString = false;
+        //         if (stringMatchs.length == 1 && stringMatchs[0][0] == bodyLine) {
+        //             let stringMatchFirst = stringMatchs[0];
+        //             let stringLine = stringMatchFirst[0];
+        //             if (stringLine.startsWith("$") || stringLine.startsWith("@$")) {
+        //                 let stringContent = stringMatchFirst[1];
+        //                 const variableMatches0 = [...stringContent.matchAll(CSCodeScanner.interpolationPattern)];
+        //                 isSingleString = variableMatches0.length == 0;
+        //             } else {
+        //                 isSingleString = true;
+        //             }
+        //         }
+        //         if (isSingleString) {
+        //             let stringMatchFirst = stringMatchs[0];
+        //             let stringLineIndex = stringMatchFirst.index;
+        //             let prefix = bodyLine.substring(0, stringLineIndex);
+        //             let stringLineFirst = stringMatchFirst[0];
+        //             if (this.isNativeString(stringLineFirst)) {
+        //                 convertedAssignLine = assignHead + prefix + stringMatchFirst[0] + ";";
+        //             } else {
+        //                 convertedAssignLine = assignHead + prefix + stringMatchFirst[0] + `.${trmethodname}();`;
+        //             }
+        //         } else {
+        //             let stringLines: string[] = [];
+        //             stringLines.push(assignHead);
+        //             let lastIndex = 0;
+        //             for (let i = 0; i < stringMatchs.length; i++) {
+        //                 let stringMatch = stringMatchs[i];
+        //                 let stringLine = stringMatch[0];
+        //                 let stringContent = stringMatch[1];
+        //                 let stringLineIndex = stringMatch.index;
+        //                 let stringStartIndexInContent = assignMatch.index + assignHead.length + stringMatch.index
+        //                 /**
+        //                  * 转换后的字符串
+        //                  */
+        //                 let convertedString: string;
+        //                 if (stringLine.startsWith("$") || stringLine.startsWith("@$")) {
+        //                     // 开始转换插值
+        //                     // 提取插值表达式中的变量
+        //                     const variableMatches0 = [...stringContent.matchAll(CSCodeScanner.interpolationPattern)];
+        //                     if (variableMatches0.length > 0) {
+        //                         let variableMatches: RegExpExecArray[] = [];
+        //                         let map = new Map<string, RegExpExecArray>();
+        //                         for (const variableMatche of variableMatches0) {
+        //                             if (!map.has(variableMatche[1])) {
+        //                                 map.set(variableMatche[1], variableMatche);
+        //                                 variableMatches.push(variableMatche);
+        //                             }
+        //                         }
+        //                         // 构建格式化字符串
+        //                         let formatString = stringContent;
+        //                         variableMatches.forEach((variableMatche, index) => {
+        //                             let varName = variableMatche[1];
+        //                             let suffix = variableMatche[2] ?? "";
+        //                             let replaced = formatString.replaceAll(`{${varName}${suffix}}`, `{${index}${suffix}}`);
+        //                             if (replaced == formatString) {
+        //                                 let [lineNum, colNum] = CSCodeScanner.getLineIndexFromIndex(content, stringStartIndexInContent);
+        //                                 let tip = `可能无法处理的复杂情形1(${filePath}:${lineNum}:${colNum}): ${stringContent}`;
+        //                                 console.error(tip);
+        //                                 unexpects.push(tip);
+        //                             } else {
+        //                                 formatString = replaced;
+        //                             }
+        //                         });
+        //                         // 构建string.Format调用
+        //                         let formatCall = `string.Format("${formatString}"`;
+        //                         for (const variableMatche of variableMatches) {
+        //                             let varName = variableMatche[1];
+        //                             formatCall += `, ${varName}`;
+        //                         }
+        //                         formatCall += ")";
+        //                         convertedString = formatCall;
+        //                         literals.push(formatString);
+        //                     } else {
+        //                         // throw new Error("暂不支持插值字符串转换为 string.Format, 请手动处理");
+        //                         let isValidFormat = true;
+        //                         if (stringContent.indexOf("{") != -1 || stringContent.indexOf("}") != -1) {
+        //                             if (bodyLine.indexOf("{") != -1 && bodyLine.indexOf("}") != -1) {
+        //                                 let [lineNum, colNum] = CSCodeScanner.getLineIndexFromIndex(content, stringStartIndexInContent);
+        //                                 let tip = `可能无法处理的复杂情形2(${filePath}:${lineNum}:${colNum}): ${stringContent}`;
+        //                                 console.error(tip);
+        //                                 unexpects.push(tip);
+        //                                 isValidFormat = false;
+        //                             }
+        //                         }
+        //                         let formattedStringLine = stringLine;
+        //                         if (isValidFormat) {
+        //                             // let stringStartIndex = stringMatch.index
+        //                             // let stringEndIndex = stringStartIndex + stringLine.length
+        //                             // let prefix = bodyLine.substring(stringStartIndex - 2, stringStartIndex)
+        //                             // let suffix = bodyLine.substring(stringEndIndex, stringEndIndex + ".TR()".length)
+        //                             // if ((stringStartIndex == 0 || prefix == "+ ") && suffix != ".TR()") {
+        //                             //     formattedStringLine = formattedStringLine + ".TR()"
+        //                             // }
+        //                             formattedStringLine = this.replaceStringsTR(stringMatch, stringLine, bodyLine, trmethodname);
+        //                             literals.push(stringContent);
+        //                         }
+        //                         convertedString = formattedStringLine;
+        //                     }
+        //                 } else {
+        //                     literals.push(stringContent);
+        //                     convertedString = this.replaceStringsTR(stringMatch, stringLine, bodyLine, trmethodname);
+        //                 }
+        //                 // 串联字符串列表
+        //                 let prefix = bodyLine.substring(lastIndex, stringLineIndex);
+        //                 lastIndex = stringLineIndex + stringLine.length;
+        //                 stringLines.push(prefix);
+        //                 stringLines.push(convertedString);
+        //             }
+        //             let matchEnd = stringMatchs[stringMatchs.length - 1];
+        //             let endIndex = matchEnd.index + matchEnd[0].length;
+        //             stringLines.push(bodyLine.substring(endIndex));
+        //             stringLines.push(";");
+        //             convertedAssignLine = stringLines.join("");
+        //         }
+        //     } else {
+        //         let convertBodyLine = CSCodeScanner.handleMembersConvert(bodyLine, assignHead, trmethodname)
+        //         if (convertBodyLine != null) {
+        //             convertedAssignLine = (assignHead ?? "") + convertBodyLine;
+        //         } else {
+        //             convertedAssignLine = assignLine
+        //         }
+        //     }
+        //     let convertedAssignLine2 = convertedAssignLine.replaceAll(this.stringFormatPattern, `${trclassname}.Format`);
+        //     snippets.push({
+        //         originalIndex: assignMatch.index,
+        //         originalCode: assignLine,
+        //         convertedCode: convertedAssignLine2,
+        //         literals,
+        //         unexpects,
+        //     });
+        // }
+        let capturer = new CSharpStringExtractor_1.CSharpStringExtractor();
+        capturer.extractStrings(content, snippets, trclassname, trmethodname);
+        return snippets;
+    }
+    static filterSnippets(snippets) {
+        let len = snippets.length;
+        for (let i = len - 1; i >= 0; i--) {
+            let snippet = snippets[i];
+            let needReplace = snippet.literals.some(literal => {
+                const needTr = LiteralCollector_1.LiteralCollector.needTranslate(literal);
+                return needTr;
+            });
+            if (!needReplace) {
+                snippets.splice(i, 1);
+            }
+        }
+    }
+    static handleMembersConvert(bodyLine, assignHead, trmethodname) {
+        let convertedAssignLine;
+        let memberLines = bodyLine.split("+");
+        if (assignHead != 'return ' && memberLines.length > 0) {
+            for (let i = 0; i < memberLines.length; i++) {
+                let memberLine = memberLines[i];
+                let regex = this.getMemberValuePattern(trmethodname);
+                let match = memberLine.match(regex);
+                if (match != null) {
+                    let value = match[2];
+                    if (value != 'null' && value != 'true' && value != 'false' && !this.isNumericString(value)) {
+                        memberLines[i] = match[1] + match[2] + `.${trmethodname}()` + match[4];
+                    }
+                }
+            }
+            convertedAssignLine = memberLines.join("+") + ";";
+        }
+        else {
+            convertedAssignLine = null;
+        }
+        return convertedAssignLine;
+    }
+    static isNumericString(str) {
+        if (typeof str !== 'string')
+            return false;
+        const num = Number(str);
+        return Number.isFinite(num) && String(num) === str.trim(); // 防止 ' 123 ' → 误判（可选严格匹配）
+    }
+    static replaceStringsTR(stringMatch, stringLine, bodyLine, trmethodname) {
+        if (this.isNativeString(stringLine)) {
+            return stringLine;
+        }
+        let trmethodcall = `.${trmethodname}()`;
+        let formattedStringLine = stringLine;
+        let stringStartIndex = stringMatch.index;
+        let stringEndIndex = stringStartIndex + stringLine.length;
+        let prefix = bodyLine.substring(stringStartIndex - 2, stringStartIndex);
+        let suffix = bodyLine.substring(stringEndIndex, stringEndIndex + trmethodcall.length);
+        if ((stringStartIndex == 0 || prefix == "+ " || prefix == ": ") && suffix != trmethodcall) {
+            formattedStringLine = formattedStringLine + trmethodcall;
+        }
+        return formattedStringLine;
+    }
+    static replaceInFile(content, snippets) {
+        let parts = [];
+        if (snippets.length > 0) {
+            let lastIndex = 0;
+            for (const snippet of snippets) {
+                let part = content.substring(lastIndex, snippet.originalIndex);
+                lastIndex = snippet.originalIndex + snippet.originalCode.length;
+                parts.push(part);
+                parts.push(snippet.convertedCode);
+            }
+            let endSnippet = snippets[snippets.length - 1];
+            let partEnd = content.substring(endSnippet.originalIndex + endSnippet.originalCode.length);
+            parts.push(partEnd);
+        }
+        try {
+            let convertedContent = parts.join("");
+            return convertedContent;
+        }
+        catch (err) {
+            console.error(`替换字符串失败: ${err}`);
+            return content;
+        }
+    }
+}
+exports.CSCodeScanner = CSCodeScanner;

package/dist/src/CSVUtils.js

@@ -0,0 +1,220 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSVUtils = void 0;
+const csv = __importStar(require("fast-csv"));
+const fs = __importStar(require("fs"));
+class CSVUtils {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async parseCsv() {
+        if (fs.existsSync(this.filePath)) {
+            let stream = csv.parseFile(this.filePath, {
+                delimiter: ",",
+            });
+            let rows = await stream.toArray();
+            stream.destroy();
+            return rows;
+        }
+        else {
+            console.error(`文件不存在: ${this.filePath}`);
+            return [];
+        }
+    }
+    getShortKey(content) {
+        // let max = 16
+        // if (content.length < max) {
+        //     return content
+        // } else {
+        //     return content.substring(0, max)
+        // }
+        return content;
+    }
+    tryGetEntry(content, map01, map02) {
+        if (map02.has(content)) {
+            let row2 = map02.get(content);
+            return [row2 != null, content, row2];
+        }
+        let shortKey = this.getShortKey(content);
+        if (map01.has(shortKey)) {
+            let row1 = map01.get(shortKey);
+            if (row1 != null && (row1[0] == shortKey || row1[1] == content)) {
+                return [true, shortKey, row1];
+            }
+            else {
+                return [false, shortKey, undefined];
+            }
+        }
+        return [false, shortKey, undefined];
+    }
+    merge(rows0, rows1, langs) {
+        // 短key
+        let map01 = new Map();
+        // 全文key
+        let map02 = new Map();
+        if (rows0 != null) {
+            for (let index = 1; index < rows0.length; index++) {
+                const row = rows0[index];
+                let key = row[0];
+                map01.set(key, row);
+            }
+            for (let index = 1; index < rows0.length; index++) {
+                const row = rows0[index];
+                let key = row[1];
+                if (key != null && key != "") {
+                    map02.set(key, row);
+                }
+            }
+        }
+        let rows2 = [];
+        if (rows0 != null && rows0.length > 0) {
+            // rows2.push(rows0[0]);
+            // 合并 langs 中没有的语言列
+            let headers = [...rows0[0]];
+            for (const lang of langs) {
+                if (!headers.includes(lang)) {
+                    headers.push(lang);
+                }
+            }
+            rows2.push(headers);
+        }
+        else {
+            rows2.push(["key", ...langs]);
+        }
+        for (let index = 0; index < rows1.length; index++) {
+            const content = rows1[index];
+            let [exist, key, row] = this.tryGetEntry(content, map01, map02);
+            if (exist) {
+                if (row != null) {
+                    rows2.push(row);
+                }
+                else {
+                    if (key != content) {
+                        rows2.push([key, content]);
+                    }
+                    else {
+                        rows2.push([content, '']);
+                    }
+                }
+            }
+            else {
+                if (key != content) {
+                    rows2.push([key, content]);
+                }
+                else {
+                    rows2.push([content, '']);
+                }
+            }
+        }
+        return rows2;
+    }
+    static async writeCsv(filePath, rows) {
+        let str = await csv.writeToString(rows);
+        fs.writeFileSync(filePath, str, "utf-8");
+    }
+    static async updateToFile(filePath, literals, langs) {
+        let csvUtils = new CSVUtils(filePath);
+        let rows0 = await csvUtils.parseCsv();
+        // 优化：使用Set去重，减少重复处理
+        const uniqueLiterals = [...new Set(literals)];
+        let rows2 = csvUtils.merge(rows0, uniqueLiterals, langs);
+        await CSVUtils.writeCsv(filePath, rows2);
+        console.log(`已经更新多语言表: ${filePath} , 共有 ${rows2.length - 1} 条目`);
+    }
+    /**
+     * 表格第一列为 key + 语言列表, 按照 langs 精简表格列, 只保留指定key列和指定语言列
+     * @param filePath csv文件路径
+     * @param outFilePath 输出csv文件路径
+     * @param langs 指定要保留的语言列表
+     */
+    static async slimCsvWithLangs(filePaths, outFilePath, langs) {
+        let rows2 = [];
+        let keySpace = new Set();
+        let conflictKeySpace = new Set();
+        let existAnyInput = false;
+        for (const filePath of filePaths) {
+            if (fs.existsSync(filePath) == false) {
+                console.warn(`文件不存在: ${filePath}`);
+                continue;
+            }
+            existAnyInput = true;
+            let csvUtils = new CSVUtils(filePath);
+            let rows0 = await csvUtils.parseCsv();
+            let header = rows0[0];
+            if (rows2.length == 0) {
+                rows2.push([header[0], ...langs]);
+            }
+            let langIndexes = [];
+            for (const lang of langs) {
+                let langIndex = header.indexOf(lang);
+                if (langIndex != -1) {
+                    langIndexes.push(langIndex);
+                }
+            }
+            for (let index = 1; index < rows0.length; index++) {
+                const row = rows0[index];
+                let newRow = [];
+                let key = row[0];
+                if (keySpace.has(key)) {
+                    conflictKeySpace.add(key);
+                }
+                else {
+                    keySpace.add(key);
+                }
+                newRow.push(key);
+                for (const langIndex of langIndexes) {
+                    newRow.push(row[langIndex]);
+                }
+                rows2.push(newRow);
+            }
+        }
+        if (existAnyInput == false) {
+            console.warn(`不存在有效文件, 未输出文件:`, filePaths);
+            return;
+        }
+        if (rows2.length > 0) {
+            await CSVUtils.writeCsv(outFilePath, rows2);
+            if (conflictKeySpace.size > 0) {
+                console.error(`冲突的key有 ${conflictKeySpace.size} 个:`, conflictKeySpace);
+            }
+        }
+        else {
+            console.warn(`没有生成任何数据，未输出文件。`);
+        }
+    }
+}
+exports.CSVUtils = CSVUtils;