@wangyh-quuo/i18n-refactor 1.0.0

package/dist/main.esm.js

@@ -0,0 +1,879 @@
+#!/usr/bin/env node
+import * as commander from 'commander';
+import fs from 'fs';
+import xlsx from 'xlsx';
+import path from 'path';
+import { parse } from '@babel/parser';
+import * as _traverse from '@babel/traverse';
+import md5 from 'md5';
+import MagicString from 'magic-string';
+import { parse as parse$1 } from '@vue/compiler-sfc';
+import { compile, NodeTypes } from '@vue/compiler-dom';
+import { isObject, merge, omit } from 'lodash-es';
+import fg from 'fast-glob';
+import { pathToFileURL } from 'url';
+
+var name = "@wangyh-quuo/i18n-refactor";
+var version = "1.0.0";
+var description = "AST-based i18n refactoring tool for Vue & TypeScript";
+var packageJson = {
+	name: name,
+	version: version,
+	description: description};
+
+const DEFAULT_SOURCE_DIR = 'src';
+var config = {
+    // 要扫描的目录
+    sourceDir: DEFAULT_SOURCE_DIR,
+    // 输出的 JSON 和 Excel 路径
+    output: {
+        json: './locales/zh.json',
+        excel: './output/i18n.xlsx',
+    },
+    // 支持的语言列表
+    languages: ['zh_CN', 'en_US'],
+    // 是否导出 Excel
+    exportExcel: true,
+    // key 生成规则（可以后面提供多个策略）
+    keyStrategy: {
+        default: 'prefix_increment', // prefix_increment or 'hash'
+        prefixRoots: [`${DEFAULT_SOURCE_DIR}/*`], // 作为模块前缀的根目录列表
+    },
+};
+
+function createContext(config) {
+    return {
+        config,
+        zhMap: {},
+        existingJson: {},
+        lastIds: {},
+        existingKeys: {},
+        notReplaceFiles: [],
+    };
+}
+const context = createContext(config);
+
+/**
+ * 多模块 i18n 导出为 Excel（每个模块一个 Sheet）
+ * @param {object} mergedJson 合并后的 JSON，如 { home: { key_1: '首页' } }
+ * @param {string} outputPath Excel 输出路径
+ */
+function exportToExcelByModule(mergedJson, outputPath = "./output/i18n.xlsx") {
+    const fullPath = path.resolve(outputPath);
+    const outputDir = path.dirname(fullPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+        console.log(`📁 已创建目录: ${outputDir}`);
+    }
+    const workbook = xlsx.utils.book_new();
+    for (const moduleKey of Object.keys(mergedJson)) {
+        const moduleData = mergedJson[moduleKey];
+        const data = Object.entries(moduleData).map(([key, zh]) => ({
+            key,
+            zh_CN: zh,
+            en_US: "", // 可预留
+        }));
+        const sheet = xlsx.utils.json_to_sheet(data);
+        xlsx.utils.book_append_sheet(workbook, sheet, moduleKey);
+    }
+    if (workbook.SheetNames.length === 0) {
+        console.log("❌ 未找到任何数据，导出取消。");
+        return;
+    }
+    xlsx.writeFile(workbook, fullPath);
+    console.log(`✅ Excel（多 Sheet）导出成功: ${fullPath}`);
+}
+
+/**
+ * 获取已存在的 zh.json 文件内容
+ * @returns {Object} 解析后的 JSON 对象
+ */
+function getExistingJson(jsonPath) {
+    let existingJson = {};
+    if (fs.existsSync(jsonPath)) {
+        const existingContent = fs.readFileSync(jsonPath, "utf-8");
+        existingJson = JSON.parse(existingContent);
+    }
+    return existingJson;
+}
+/**
+ * 将扁平对象转换为嵌套对象
+ * @param {Object} flatObj 扁平对象
+ * @returns {Object} 嵌套对象
+ */
+function flatToNested(flatObj) {
+    const nested = {};
+    for (const key in flatObj) {
+        const parts = key.split(".");
+        let current = nested;
+        parts.forEach((part, index) => {
+            if (!current[part]) {
+                current[part] = index === parts.length - 1 ? flatObj[key] : {};
+            }
+            current = current[part];
+        });
+    }
+    return nested;
+}
+/**
+ * 合并现有的 JSON 和新生成的 JSON
+ * @param {Object} newJson 新生成的 JSON 对象
+ * @returns {Object} 合并后的 JSON 对象
+ */
+function mergeZhJson(newJson) {
+    const existingJson = getExistingJson(context.config.output.json);
+    // 使用递归合并现有的 JSON 和新生成的 JSON
+    function deepMerge(target, source) {
+        for (const key in source) {
+            if (source.hasOwnProperty(key)) {
+                if (typeof source[key] === "object" && !Array.isArray(source[key])) {
+                    if (!target[key])
+                        target[key] = {};
+                    deepMerge(target[key], source[key]);
+                }
+                else {
+                    target[key] = source[key];
+                }
+            }
+        }
+    }
+    deepMerge(existingJson, newJson);
+    return existingJson;
+}
+function writeJsonToFile() {
+    const nested = flatToNested(context.zhMap);
+    const mergedZhJson = mergeZhJson(nested);
+    const localesDir = context.config.output.json.split("/").slice(0, -1).join("/");
+    fs.mkdirSync(localesDir, { recursive: true });
+    fs.writeFileSync(context.config.output.json, JSON.stringify(mergedZhJson, null, 2), "utf-8");
+    console.log(`\n🎉 全部处理完成！已生成并合并: ${context.config.output.json}`);
+    if (context.config.exportExcel) {
+        exportToExcelByModule(mergedZhJson, context.config.output.excel);
+    }
+}
+
+const traverse = 
+// CJS + ESM + bundler 全兼容
+(_traverse.default?.default ??
+    _traverse.default ??
+    _traverse);
+
+/**
+ * 匹配文件路径是否符合指定的目录模式
+ * @param {string} filePath 文件路径
+ * @param {string[]} patterns 目录模式数组
+ * @returns {Object} { matched: boolean, root: string }
+ */
+function matchRootDir(filePath, patterns) {
+    const normalized = path.normalize(filePath);
+    for (const pattern of patterns) {
+        const normalizedPattern = path.normalize(pattern);
+        // 精确目录：src/pages
+        if (!normalizedPattern.endsWith(path.normalize('/*'))) {
+            if (normalized.startsWith(normalizedPattern + path.sep)) {
+                return { matched: true, root: normalizedPattern };
+            }
+            continue;
+        }
+        // 通配目录：src/*
+        const baseDir = normalizedPattern.replace(path.normalize('/*'), '');
+        if (!normalized.startsWith(baseDir + path.sep)) {
+            continue;
+        }
+        // src/a/b/c.vue => b/c.vue
+        const rest = normalized.slice(baseDir.length + 1);
+        const segments = rest.split(path.sep);
+        if (segments.length >= 2) {
+            return { matched: true, root: baseDir + path.sep + segments[0] };
+        }
+    }
+    return { matched: false, root: '' };
+}
+function isChinese(str) {
+    return /[\u4e00-\u9fa5]/.test(str);
+}
+function containsHTML(text) {
+    return /<\/?[a-z][\s\S]*>/i.test(text);
+}
+
+/**
+ * 获取该模块的最后一个 id
+ * @param {Object} existingJson 已存在的 JSON 对象
+ * @returns {Object} 每个模块的最后一个 id
+ */
+function getLastKeyId(existingJson) {
+    const lastIds = {};
+    function traverse(obj, prefix = null) {
+        for (const key in obj) {
+            if (typeof obj[key] === "object" && !Array.isArray(obj[key])) {
+                traverse(obj[key], key);
+            }
+            else if (key.startsWith("key_")) {
+                const id = parseInt(key.split("_")[1]);
+                if (prefix && (!lastIds[prefix] || id > lastIds[prefix])) {
+                    lastIds[prefix] = id;
+                }
+            }
+        }
+    }
+    traverse(existingJson);
+    return lastIds;
+}
+/**
+ * 初始化已存在的 key
+ * @param {Object} existingJson 已存在的 JSON 对象
+ * @returns {Object} 中文文本和 key 的映射关系
+ */
+function initExistingKeys(existingJson) {
+    const map = {};
+    for (const module in existingJson) {
+        const group = existingJson[module];
+        for (const key in group) {
+            const value = group[key];
+            map[value] = `${module}.${key}`;
+        }
+    }
+    return map;
+}
+/**
+ * 获取或生成唯一的 key
+ * @param {string} text 中文文本
+ * @param {string} prefix 模块前缀
+ * @returns {string} 唯一的 key
+ */
+function getKeyByText(text, prefix) {
+    const clean = text.trim();
+    // 如果已经存在，则直接返回对应的 key
+    if (context.existingKeys[clean])
+        return context.existingKeys[clean];
+    let key = '';
+    if (context.config.keyStrategy.default === 'prefix_increment') {
+        let id = context.lastIds[prefix] || 0; // 获取当前模块的最后一个 id，没有则从 0 开始
+        // 生成新的 key
+        key = `${prefix}.key_${++id}`;
+        // 更新模块的 ID
+        context.lastIds[prefix] = id;
+    }
+    else if (context.config.keyStrategy.default === 'hash') {
+        const hash = md5(text).slice(0, 8); // 可控制长度
+        key = `${prefix}.${hash}`;
+    }
+    context.existingKeys[clean] = key; // 记录该中文和 key 的映射关系
+    context.zhMap[key] = clean; // 添加到最终的 zhMap
+    return key;
+}
+/**
+ * 获取页面模块前缀
+ * @param {string} filePath 文件路径
+ * @returns {string} 模块前缀
+ */
+function getPagePrefix(filePath) {
+    const matchResult = matchRootDir(filePath, context.config.keyStrategy.prefixRoots);
+    if (matchResult.matched) {
+        const normalized = path.normalize(filePath); // 保证是平台风格路径
+        const segments = normalized.replace(matchResult.root, '').split(path.sep).filter(Boolean);
+        return segments[0]; // 如 "home"
+    }
+    return "common"; // fallback
+}
+
+const logSet = new Set();
+function loggerDryRun(filePath, source, replacement) {
+    if (context.config.dryRun) {
+        if (!logSet.has(`${filePath}`)) {
+            logSet.add(`${filePath}`);
+            console.log(`[DRY RUN] Would modify: ${filePath}`);
+        }
+        console.log(`[DRY RUN] Would add key: ${replacement} from ${source.trim()}`);
+    }
+}
+
+class Replacer {
+    replacements = [];
+    constructor(replacements) {
+        this.replacements = replacements;
+    }
+    replace(raw, filePath) {
+        const content = new MagicString(raw);
+        for (const r of this.replacements) {
+            content.overwrite(r.start, r.end, r.replacement);
+            loggerDryRun(filePath, r.source, r.replacement);
+        }
+        const replacedContent = content.toString();
+        return replacedContent;
+    }
+    static updateFile(filePath, replacedContent) {
+        if (!context.config.dryRun) {
+            fs.writeFileSync(filePath, replacedContent, "utf-8");
+            console.log(`✅ 处理完成: ${filePath}`);
+        }
+    }
+}
+
+class ScriptParser {
+    filePath;
+    rawContent;
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.rawContent = "";
+        if (fs.existsSync(filePath)) {
+            this.rawContent = fs.readFileSync(filePath, "utf-8");
+        }
+    }
+    static parseScript(content, filePath) {
+        const ast = parse(content, {
+            sourceType: "module",
+            plugins: ["typescript", "jsx"],
+        });
+        const replacements = [];
+        traverse(ast, {
+            StringLiteral(path) {
+                const { node } = path;
+                if (!/[\u4e00-\u9fff]/.test(node.value)) {
+                    return;
+                }
+                // 排除 import / key
+                if (path.parent.type === "ImportDeclaration" ||
+                    (path.parent.type === "ObjectProperty" &&
+                        path.parent.key === node &&
+                        !path.parent.computed)) {
+                    return;
+                }
+                const key = getKeyByText(node.value, getPagePrefix(filePath));
+                replacements.push({
+                    start: node.start,
+                    end: node.end,
+                    original: node.value,
+                    source: node.value,
+                    replacement: `t('${key}')`,
+                });
+            },
+            // 模板字符串 const msg = `你好${name}同学`; --> `${t('key_1', { 0: name })}`
+            TemplateLiteral(path) {
+                const { quasis, expressions } = path.node;
+                if (quasis.some((q) => containsHTML(q.value.cooked || q.value.raw))) {
+                    if (quasis.some((q) => isChinese(q.value.cooked || q.value.raw))) {
+                        context.notReplaceFiles.push({
+                            source: quasis.map(q => q.value.cooked || q.value.raw).join("${...}"),
+                            filePath: filePath,
+                            reason: '模板字符串中包含HTML，暂不支持自动替换',
+                        });
+                    }
+                    return;
+                }
+                const needReplace = quasis.some((q) => isChinese(q.value.cooked || q.value.raw)) &&
+                    expressions.length &&
+                    expressions.every((exp) => ["Identifier", "MemberExpression"].includes(exp.type));
+                if (needReplace) {
+                    const pos = { start: 0, end: 0 };
+                    let combinedText = "";
+                    let i = 0;
+                    let tempList = [];
+                    const children = [...quasis, ...expressions].sort((a, b) => a.start - b.start);
+                    children.forEach((child) => {
+                        if (!pos.start) {
+                            pos.start = child.start;
+                        }
+                        if (child.type === "TemplateElement") {
+                            combinedText += child.value.cooked || "";
+                        }
+                        else if (child.type === "Identifier") {
+                            combinedText += `{${i}}`;
+                            tempList.push(child.name);
+                        }
+                        else if (child.type === "MemberExpression") {
+                            combinedText += `{${i}}`;
+                            tempList.push(content.slice(child.start, child.end));
+                        }
+                        pos.end = child.end;
+                    });
+                    const key = getKeyByText(combinedText, getPagePrefix(filePath));
+                    replacements.push({
+                        start: pos.start,
+                        end: pos.end,
+                        original: combinedText,
+                        source: combinedText,
+                        replacement: `\${t('${key}', { ${tempList.map((_, index) => `${index}: ${tempList[index]}`).join(", ")} })}`
+                    });
+                    return;
+                }
+                else {
+                    quasis.forEach((quasi) => {
+                        const cooked = quasi.value.cooked || quasi.value.raw;
+                        if (!/[\u4e00-\u9fff]/.test(cooked)) {
+                            return;
+                        }
+                        if (quasi.start == null || quasi.end == null) {
+                            return;
+                        }
+                        const key = getKeyByText(cooked, getPagePrefix(filePath));
+                        replacements.push({
+                            start: quasi.start,
+                            end: quasi.end,
+                            original: cooked,
+                            source: cooked,
+                            replacement: `\${t('${key}')}`,
+                        });
+                    });
+                }
+            },
+        });
+        return replacements;
+    }
+    process() {
+        const replacements = ScriptParser.parseScript(this.rawContent, this.filePath);
+        return new Replacer(replacements).replace(this.rawContent, this.filePath);
+    }
+}
+
+function getSourceReplacePosition(sourceLocation) {
+    const source = sourceLocation.source;
+    let start = 0;
+    let end = source.length;
+    // 去掉前面的纯缩进（空格 + 换行）
+    while (start < end &&
+        (source[start] === ' ' ||
+            source[start] === '\n' ||
+            source[start] === '\r' ||
+            source[start] === '\t')) {
+        start++;
+    }
+    // 去掉尾部的纯缩进
+    while (end > start &&
+        (source[end - 1] === ' ' ||
+            source[end - 1] === '\n' ||
+            source[end - 1] === '\r' ||
+            source[end - 1] === '\t')) {
+        end--;
+    }
+    return {
+        start: start + sourceLocation.start.offset,
+        end: sourceLocation.end.offset - (source.length - end),
+    };
+}
+class VueParser {
+    filePath;
+    rawContent;
+    templateContent;
+    scriptContent;
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.rawContent = '';
+        this.templateContent = "";
+        this.scriptContent = "";
+        this.parse();
+    }
+    parse() {
+        if (!fs.existsSync(this.filePath)) {
+            return;
+        }
+        this.rawContent = fs.readFileSync(this.filePath, "utf-8");
+        const { descriptor } = parse$1(this.rawContent);
+        if (descriptor.template) {
+            this.templateContent = descriptor.template.content;
+        }
+        if (descriptor.script || descriptor.scriptSetup) {
+            const scriptBlock = descriptor.scriptSetup || descriptor.script;
+            const scriptContent = scriptBlock?.content;
+            if (scriptContent) {
+                this.scriptContent = scriptContent;
+            }
+        }
+    }
+    processTemplate(templateContent, filePath) {
+        const ast = compile(templateContent, { mode: "module" }).ast;
+        const prefix = getPagePrefix(filePath);
+        const replacements = [];
+        const handleCompoundExpression = this.handleCompoundExpression.bind(this);
+        const handleArrayExpression = this.handleArrayExpression.bind(this);
+        function walk(node, replacement) {
+            if (node.type === NodeTypes.COMMENT) {
+                return;
+            }
+            if (node.type === NodeTypes.TEXT) {
+                const text = node.content.trim();
+                if (text && isChinese(text)) {
+                    const key = getKeyByText(text, prefix);
+                    replacements.push({
+                        ...getSourceReplacePosition(node.loc),
+                        original: text,
+                        source: node.loc.source, // 换行文本兼容处理
+                        replacement: replacement ? replacement(key) : `{{ $t('${key}') }}`,
+                    });
+                }
+            }
+            // if
+            else if (node.type === NodeTypes.IF) {
+                if (node.branches) {
+                    node.branches.forEach((branch) => walk(branch));
+                }
+            }
+            // 插槽
+            else if (node.type === NodeTypes.TEXT_CALL) {
+                walk(node.content);
+            }
+            // 2. 标签属性中的中文
+            else if (node.type === NodeTypes.ELEMENT && node.props) {
+                node.props.forEach((prop) => walk(prop));
+            }
+            // 属性
+            else if (node.type === NodeTypes.ATTRIBUTE) {
+                const nameLoc = node.nameLoc;
+                // 非动态绑定属性才需要添加 : 前缀
+                if (!nameLoc.source.startsWith(":") &&
+                    node.value?.content &&
+                    isChinese(node.value.content)) {
+                    replacements.push({
+                        ...getSourceReplacePosition(nameLoc),
+                        original: nameLoc.source,
+                        replacement: `:${nameLoc.source}`,
+                    });
+                }
+                // 处理属性值中的中文
+                if (node.value) {
+                    walk(node.value, (k) => `"$t('${k}')"`);
+                }
+            }
+            // 指令
+            else if (node.type === NodeTypes.DIRECTIVE) {
+                if (!node.exp) {
+                    return;
+                }
+                walk(node.exp);
+            }
+            // 表达式
+            else if (node.type === NodeTypes.SIMPLE_EXPRESSION) {
+                const text = node.content.trim();
+                if (node.ast &&
+                    text &&
+                    isChinese(text)) {
+                    if (node.ast.type === "StringLiteral") {
+                        const key = getKeyByText(text, prefix);
+                        replacements.push({
+                            ...getSourceReplacePosition(node.loc),
+                            original: text,
+                            source: node.loc.source,
+                            replacement: replacement ? replacement(key) : `$t('${key}')`,
+                        });
+                    }
+                    else if (node.ast.type === 'ArrayExpression') {
+                        // 数组表达式中的中文
+                        replacements.push(...handleArrayExpression(node, node.ast, prefix));
+                    }
+                }
+            }
+            else if (node.type === NodeTypes.COMPOUND_EXPRESSION) {
+                const compoundReplace = handleCompoundExpression(node, prefix);
+                if (compoundReplace) {
+                    Array.isArray(compoundReplace)
+                        ? replacements.push(...compoundReplace)
+                        : replacements.push(compoundReplace);
+                }
+                return;
+            }
+            else if (node.type === NodeTypes.INTERPOLATION) {
+                walk(node.content);
+            }
+            // ParentNode
+            if ("children" in node && node.children) {
+                node.children.forEach((child) => {
+                    if (typeof child === "object") {
+                        walk(child);
+                    }
+                });
+            }
+        }
+        walk(ast);
+        return replacements;
+    }
+    handleCompoundExpression(node, prefix) {
+        const children = node.children;
+        const needReplace = children.every(c => typeof c === 'string' || (typeof c === 'object' && (c.type === NodeTypes.TEXT || c.type === NodeTypes.INTERPOLATION)));
+        if (children.length && needReplace) {
+            const pos = { start: 0, end: 0 };
+            let combinedText = '';
+            let i = 0;
+            let tempList = [];
+            children.forEach((child) => {
+                if (typeof child === 'object') {
+                    const childPos = getSourceReplacePosition(child.loc);
+                    if (!pos.start) {
+                        pos.start = childPos.start;
+                    }
+                    if (child.type === NodeTypes.TEXT) {
+                        combinedText += child.content;
+                    }
+                    else if (child.type === NodeTypes.INTERPOLATION) {
+                        combinedText += `{${i}}`;
+                        tempList.push(child.content.loc.source);
+                        i++;
+                    }
+                    pos.end = childPos.end;
+                }
+            });
+            if (!isChinese(combinedText)) {
+                return null;
+            }
+            const key = getKeyByText(combinedText, prefix);
+            return {
+                start: pos.start,
+                end: pos.end,
+                original: node.loc.source,
+                source: node.loc.source,
+                // $t('', { 0: xxx })
+                replacement: `{{ $t('${key}', { ${tempList.map((_, index) => `${index}: ${tempList[index]}`).join(', ')} }) }}`
+            };
+        }
+        else {
+            if (/\$t\(.*\)$/.test(node.loc.source)) {
+                return null;
+            }
+            if (node.ast && node.ast.type === 'ConditionalExpression') {
+                return this.handleConditionalExpression(node, node.ast, prefix);
+            }
+            // 混合表达式暂不支持自动替换
+            if (isChinese(node.loc.source)) {
+                context.notReplaceFiles.push({
+                    source: node.loc.source,
+                    filePath: this.filePath,
+                    reason: '混合表达式暂不支持自动替换',
+                });
+            }
+        }
+        return null;
+    }
+    handleConditionalExpression(node, ast, prefix) {
+        if (!ast || ast.type !== 'ConditionalExpression') {
+            return [];
+        }
+        const { consequent, alternate } = ast;
+        const res = [];
+        if (consequent.type === 'StringLiteral' && isChinese(consequent.value)) {
+            const key = getKeyByText(consequent.value, prefix);
+            res.push({
+                start: consequent.start + node.loc.start.offset - 1,
+                end: consequent.end + node.loc.start.offset,
+                original: consequent.value,
+                source: consequent.value,
+                replacement: `$t('${key}') `,
+            });
+        }
+        else {
+            res.push(...this.handleConditionalExpression(node, consequent, prefix));
+        }
+        if (alternate.type === 'StringLiteral' && isChinese(alternate.value)) {
+            const key = getKeyByText(alternate.value, prefix);
+            res.push({
+                start: alternate.start + node.loc.start.offset - 1,
+                end: alternate.end + node.loc.start.offset - 1,
+                original: alternate.value,
+                source: alternate.value,
+                replacement: `$t('${key}')`,
+            });
+        }
+        else {
+            res.push(...this.handleConditionalExpression(node, alternate, prefix));
+        }
+        return res;
+    }
+    handleArrayExpression(node, ast, prefix) {
+        const res = [];
+        if (ast && ast.type === 'ArrayExpression') {
+            const elements = ast.elements;
+            elements.forEach((el) => {
+                if (isObject(el) && el.type === 'StringLiteral' && isChinese(el.value)) {
+                    const key = getKeyByText(el.value, prefix);
+                    res.push({
+                        start: el.start + node.loc.start.offset - 1,
+                        end: el.end + node.loc.start.offset - 1,
+                        original: el.value,
+                        source: el.value,
+                        replacement: `$t('${key}')`,
+                    });
+                }
+                else if (isObject(el) && el.type === 'ArrayExpression') {
+                    res.push(...this.handleArrayExpression(node, el, prefix));
+                }
+            });
+        }
+        return res;
+    }
+    setScriptContent(scriptContent) {
+        this.scriptContent = scriptContent;
+    }
+    setTemplateContent(templateContent) {
+        this.templateContent = templateContent;
+    }
+    process() {
+        const templateReplacements = this.processTemplate(this.templateContent, this.filePath);
+        const scriptReplacements = ScriptParser.parseScript(this.scriptContent, this.filePath);
+        const templateReplacedContent = new Replacer(templateReplacements).replace(this.templateContent, this.filePath);
+        const scriptReplacedContent = new Replacer(scriptReplacements).replace(this.scriptContent, this.filePath);
+        const replacedContent = this.rawContent.replace(this.templateContent, templateReplacedContent).replace(this.scriptContent, scriptReplacedContent);
+        return replacedContent;
+    }
+}
+
+class parserFactory {
+    static getParser(filePath) {
+        if (path.extname(filePath) === '.vue') {
+            return new VueParser(filePath);
+        }
+        else if (['.js', '.ts', '.jsx', '.tsx'].includes(path.extname(filePath))) {
+            return new ScriptParser(filePath);
+        }
+        return null;
+    }
+}
+
+const chineseRegexp = /[\u4e00-\u9fa5]/g;
+/**
+ * 判断文本是否已被翻译函数包裹
+ * t('xx')
+ * $t('xx')
+ * :title="$t('xx')"
+ * label: t('xx')
+ */
+function isWrappedByT(line) {
+    // t( 或 $t(
+    const tRegexp = /\$t\s*\(|\bt\s*\(/;
+    return tRegexp.test(line);
+}
+class Scanner {
+    sourceDir = "";
+    constructor(sourceDir) {
+        this.sourceDir = sourceDir;
+    }
+    async scan() {
+        const files = await fg([this.sourceDir + "/**/*.{vue,js,ts,jsx,tsx}"]);
+        return files;
+    }
+    scanFileForUntranslated(filePath) {
+        const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+        const untranslated = [];
+        lines.forEach((line, index) => {
+            if (chineseRegexp.test(line) && !isWrappedByT(line)) {
+                untranslated.push({
+                    file: filePath,
+                    line: index + 1,
+                    text: line.trim(),
+                });
+            }
+        });
+        return untranslated;
+    }
+    scanDirectoryForChinese(dir) {
+        let results = [];
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        entries.forEach((entry) => {
+            const fullPath = `${dir}/${entry.name}`;
+            if (entry.isDirectory()) {
+                const untranslated = this.scanDirectoryForChinese(fullPath);
+                if (untranslated.length > 0) {
+                    results.push(...untranslated);
+                }
+            }
+            else if (entry.isFile() && /\.(vue|js|ts)$/.test(entry.name)) {
+                const untranslated = this.scanFileForUntranslated(fullPath);
+                if (untranslated.length > 0) {
+                    results.push(...untranslated);
+                }
+            }
+        });
+        return results;
+    }
+    scanProject(rootDir) {
+        const results = this.scanDirectoryForChinese(rootDir || this.sourceDir);
+        if (results.length === 0) {
+            console.log("🎉 未发现未国际化的中文！");
+            return;
+        }
+        console.log(`\n🚨 发现 ${results.length} 处未国际化中文：\n`);
+        results.forEach((r) => {
+            console.log(`📄 ${r.file}`);
+            console.log(`   👉 行 ${r.line}: ${r.text}`);
+        });
+        console.log("\n⚠️ 请手动处理或加入自动国际化流程。\n");
+    }
+}
+
+function findProjectConfig(targetPath) {
+    if (!fs.existsSync(targetPath)) {
+        console.warn(`Path does not exist: ${targetPath}`);
+        return null;
+    }
+    let dir = fs.statSync(targetPath).isDirectory()
+        ? targetPath
+        : path.dirname(targetPath);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const configPath = path.join(dir, 'i18n.config.js');
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+async function loadProjectConfig(configPath) {
+    if (!configPath) {
+        return {};
+    }
+    const configUrl = pathToFileURL(configPath).href;
+    const config = await import(configUrl);
+    return config.default || {};
+}
+async function initContext() {
+    console.log("Initializing context...");
+    const targetPath = context.configPath || path.resolve('./');
+    const userConfig = await loadProjectConfig(findProjectConfig(targetPath));
+    context.config = merge(context.config, userConfig);
+    context.existingJson = getExistingJson(context.config.output.json);
+    context.lastIds = getLastKeyId(context.existingJson);
+    context.existingKeys = initExistingKeys(context.existingJson);
+    return context;
+}
+function initOptions(options) {
+    if (options.config) {
+        context.configPath = path.resolve(options.config);
+    }
+    context.config = merge(context.config, omit(options, 'config'));
+}
+
+async function run(options) {
+    initOptions(options || {});
+    await initContext();
+    const scanner = new Scanner(context.config.sourceDir);
+    if (context.config.scan) {
+        return scanner.scanProject();
+    }
+    const files = await scanner.scan();
+    for (const filePath of files) {
+        const parser = parserFactory.getParser(filePath);
+        if (parser) {
+            const replacedContent = parser.process();
+            Replacer.updateFile(filePath, replacedContent);
+        }
+    }
+    console.log(`----------------------------------------`);
+    context.notReplaceFiles.forEach(item => {
+        console.log(`⚠️ 未替换内容: ${item.source.trim()}，原因: ${item.reason}, 位置: ${item.filePath}`);
+    });
+    writeJsonToFile();
+}
+
+const program = new commander.Command();
+program
+    .version(`${packageJson.name} ${packageJson.version}`)
+    .description(packageJson.description)
+    .option('-s, --scan', '仅扫描未国际化的中文')
+    .option('-c, --config <path>', '指定配置文件 (默认: i18n.config.js)', 'i18n.config.js')
+    .option('--dry-run', '只分析，不写文件')
+    .action((options) => {
+    const start = performance.now();
+    run(options).finally(() => {
+        console.log(`\n⏱️ 耗时: ${(performance.now() - start).toFixed(2)} ms`);
+    });
+})
+    .parse();
+//# sourceMappingURL=main.esm.js.map