vue-i18n-auto-plugin 1.0.0

package/README.md

@@ -0,0 +1,140 @@
+# vite-plugin-i18n-auto
+
+Vite 插件，用于自动将 Vue/TypeScript 项目中的中文硬编码转换为 i18n 函数调用。
+
+## 功能特点
+
+- ✅ **基于 AST 解析**：使用 Babel 和 Vue Compiler SFC 进行代码解析
+- ✅ **智能过滤**：自动跳过 import/export、对象键、函数参数等不应国际化的上下文
+- ✅ **模板字符串支持**：自动提取 `${variable}` 变量，生成 `t('key', { name1: variable })` 格式
+- ✅ **Vue 文件完整支持**：同时处理 `<template>` 和 `<script>` 部分
+- ✅ **自动注入 i18n**：检测到中文时自动注入 `useI18n` 导入
+- ✅ **自动生成 Key**：基于 HMAC-SHA256 生成唯一 key
+
+## 安装
+
+```bash
+npm install vite-plugin-i18n-auto -D
+# 或
+yarn add vite-plugin-i18n-auto -D
+# 或
+pnpm add vite-plugin-i18n-auto -D
+```
+
+## 使用方法
+
+在 `vite.config.ts` 中配置：
+
+```typescript
+import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import I18nAutoPlugin from 'vite-plugin-i18n-auto';
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    I18nAutoPlugin({
+      i18nPath: 'src/locales/zh-CN.ts',        // 主语言文件路径
+      langPath: ['src/locales/en.ts'],         // 其他语言文件路径数组
+      regi18n: 'useI18n',                      // 判断是否已引入i18n的标识
+      excludes: ['locale', 'useI18n'],         // 排除的文件名
+      tempText: 't',                           // 模板中使用的函数名
+      jsText: 't',                             // JS中使用的函数名
+      injectToJS: `\nimport { useI18n } from 'vue-i18n'\nconst { t } = useI18n()\n`,
+      delay: 1000,                             // 防抖延迟时间（毫秒）
+      reserveKeys: [],                         // 生产环境需要保留的key
+      runBuild: true,                          // 是否在打包时执行
+      keyLength: 16,                           // 生成的key长度
+      cryptoKey: 'i18n',                       // 加密密钥
+      preText: 'common.',                      // key生成的前缀
+    }),
+  ],
+});
+```
+
+## 配置选项
+
+| 选项 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `i18nPath` | `string` | `'src/locales/zh-CN.ts'` | 主语言文件路径（通常是中文） |
+| `langPath` | `string[]` | `['src/locales/en.ts']` | 其他语言文件路径数组 |
+| `regi18n` | `string` | `'useI18n'` | 判断是否已引入i18n的标识 |
+| `excludes` | `string[]` | `['locale', 'useI18n']` | 排除的文件名或路径 |
+| `tempText` | `string` | `'t'` | 模板中使用的函数名 |
+| `jsText` | `string` | `'t'` | JS中使用的函数名 |
+| `injectToJS` | `string` | `'\nimport { useI18n } from \'vue-i18n\'\nconst { t } = useI18n()\n'` | 自动注入的代码 |
+| `delay` | `number` | `1000` | 防抖延迟时间（毫秒） |
+| `reserveKeys` | `string[]` | `[]` | 生产环境需要保留的key |
+| `runBuild` | `boolean` | `false` | 是否在打包时执行 |
+| `keyLength` | `number` | `16` | 生成的key长度 |
+| `cryptoKey` | `string` | `'i18n'` | 加密密钥 |
+| `preText` | `string` | `''` | key生成的前缀 |
+
+## 转换示例
+
+### 转换前
+
+```vue
+<template>
+  <div>
+    <h1>欢迎使用</h1>
+    <p :title="'点击查看详情'">这是一个测试</p>
+  </div>
+</template>
+
+<script setup>
+const message = `你好，${userName}！`;
+</script>
+```
+
+### 转换后
+
+```vue
+<template>
+  <div>
+    <h1>{{ t('common.xxxxx') }}</h1>
+    <p :title="t('common.yyyyy')">{{ t('common.zzzzz') }}</p>
+  </div>
+</template>
+
+<script setup>
+import { useI18n } from 'vue-i18n'
+const { t } = useI18n()
+const message = t('common.aaaaa', { name1: userName });
+</script>
+```
+
+## 语言文件格式
+
+### zh-CN.ts
+
+```typescript
+export default {
+  "common.xxxxx": "欢迎使用",
+  "common.yyyyy": "点击查看详情",
+  "common.zzzzz": "这是一个测试",
+  "common.aaaaa": "你好，{name1}！"
+}
+```
+
+### en.ts
+
+```typescript
+export default {
+  "common.xxxxx": "Welcome",
+  "common.yyyyy": "Click to view details",
+  "common.zzzzz": "This is a test",
+  "common.aaaaa": "Hello, {name1}!"
+}
+```
+
+## 注意事项
+
+1. **开发环境性能**：在开发环境启用可能会影响构建速度，建议只在生产环境启用
+2. **自动注入**：插件会自动检测并注入 `useI18n`，但如果文件结构复杂可能无法正确注入
+3. **Key 生成**：相同的中文文本总是生成相同的 key
+4. **文件格式**：语言文件必须使用 `export default` 格式
+
+## License
+
+MIT

package/dist/index.cjs.js

@@ -0,0 +1,555 @@
+'use strict';
+
+var compilerSfc = require('@vue/compiler-sfc');
+var fs = require('fs');
+var path = require('path');
+var babelParser = require('@babel/parser');
+var _generate = require('@babel/generator');
+var _traverse = require('@babel/traverse');
+var crypto = require('crypto');
+var JSON5 = require('json5');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var babelParser__namespace = /*#__PURE__*/_interopNamespaceDefault(babelParser);
+var _generate__namespace = /*#__PURE__*/_interopNamespaceDefault(_generate);
+var _traverse__namespace = /*#__PURE__*/_interopNamespaceDefault(_traverse);
+
+// 中文字符匹配函数（判断字符串是否包含中文字符）
+function containsChinese(str) {
+    return /[\u4e00-\u9fa5]/.test(str);
+}
+// 收集字符串中的字符, '我的测试' + 'abc' + '测试呀', 针对这种字符串的拼接处理
+function extractQuotedStrings(str) {
+    // 如果是 `这种拼接的`
+    const regex = /(["'])(.*?)\1/g;
+    let match;
+    const matches = [];
+    while ((match = regex.exec(str)) !== null) {
+        matches.push(match[0]);
+    }
+    return matches;
+}
+// 对js 字符串的模板进行处理 类似 `我的测试${variable}`
+function extractTransformString(str) {
+    // 正则表达式匹配 ${variable} 中的内容
+    const regex = /\$\{([^}]+)\}/g;
+    if (!regex.test(str)) {
+        return;
+    }
+    const placeholders = [];
+    let index = 1;
+    let transformedStr = str.replace(regex, (match, p1) => {
+        placeholders.push(`name${index}: ${p1}`);
+        const placeholder = `{name${index}}`;
+        index++;
+        return placeholder;
+    }).replace(/`/g, '');
+    return {
+        key: transformedStr,
+        data: placeholders.join(', ')
+    };
+}
+// 生成唯一key
+function generateKey(chineseStr) {
+    const text = (globalThis.preText || '') + chineseStr;
+    const hash = crypto.createHmac('sha256', globalThis.cryptoKey || 'i18n').update(text).digest('hex');
+    // 保留加密结果的前N位，N由配置中的keyLength决定
+    const len = globalThis.keyLength || 16;
+    return hash.slice(0, len);
+}
+// 获取和收集key
+function getChineseKey(text) {
+    let key = '';
+    if (containsChinese(text)) {
+        const chineseText = text.trim().replace(/^&%&/, '');
+        key = generateKey(chineseText);
+        if (!globalThis.translationsMap[key]) {
+            globalThis.addTranslations.push({
+                key,
+                value: chineseText
+            });
+        }
+        // 这里一定是 use key ,使用的key值，修改中文和书写中文的时候会一个 标注
+        globalThis.translationsMap[key] = chineseText;
+    }
+    let isKey = false;
+    if (text) {
+        // 使用正则的方法进行判断
+        isKey = /^&%\&/.test(text);
+    }
+    return {
+        key,
+        isKey
+    };
+}
+// 读取文件映射相关的内容
+function getFileJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    // 读取文件内容
+    const fileContent = fs.readFileSync(filePath, 'utf8');
+    // 使用贪婪模式匹配到最后一个 }
+    const objectStr = fileContent.replace(/export\s+default\s+/, '').trim();
+    try {
+        // 解析对象
+        return JSON5.parse(objectStr);
+    }
+    catch (e) {
+        console.log('解析语言映射文件报错:', filePath);
+        return {};
+    }
+}
+// 更新文件中的json
+function updateJSONInFile(filePath, obj) {
+    // 确保目录存在（兼容 Windows 和 Unix 路径）
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // 生成新的对象字符串
+    const newObjectStr = JSON.stringify(obj, null, 2);
+    // 替换回文件内容
+    const newFileContent = `export default ${newObjectStr}`;
+    // 保存文件
+    fs.writeFileSync(filePath, newFileContent, 'utf8');
+}
+function debounce(func, wait, immediate = false) {
+    let timeout;
+    return function (...args) {
+        //@ts-ignore
+        const context = this;
+        const later = () => {
+            timeout = null;
+            if (!immediate) {
+                func.apply(context, args);
+            }
+        };
+        const callNow = immediate && !timeout;
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(later, wait);
+        if (callNow) {
+            func.apply(context, args);
+        }
+    };
+}
+
+//@ts-ignore
+const traverse = _traverse__namespace.default || _traverse__namespace;
+//@ts-ignore
+const generate = _generate__namespace.default || _generate__namespace;
+// 提取 script 中的中文
+function extractChineseFromScript(content, jsText) {
+    if (!content)
+        return undefined;
+    let flag = false; // 是否有更新
+    try {
+        const ast = babelParser__namespace.parse(content, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript', 'decorators-legacy'],
+        });
+        traverse(ast, {
+            StringLiteral(path) {
+                // 第一层：AST 上下文过滤
+                const parent = path.parent;
+                // 跳过 import/export 语句
+                if (parent.type === 'ImportDeclaration' || parent.type === 'ImportSpecifier' ||
+                    parent.type === 'ExportDeclaration' || parent.type === 'ExportSpecifier') {
+                    return;
+                }
+                // 跳过 require() 调用
+                if (parent.type === 'CallExpression' &&
+                    parent.callee.type === 'Identifier' &&
+                    parent.callee.name === 'require') {
+                    return;
+                }
+                // 跳过对象属性键
+                if (parent.type === 'ObjectProperty' && parent.key === path.node) {
+                    return;
+                }
+                // 跳过函数参数名
+                if ((parent.type === 'FunctionDeclaration' || parent.type === 'FunctionExpression' ||
+                    parent.type === 'ArrowFunctionExpression') &&
+                    parent.params && parent.params.includes(path.node)) {
+                    return;
+                }
+                // 跳过变量声明标识符
+                if (parent.type === 'VariableDeclarator' && parent.id === path.node) {
+                    return;
+                }
+                // 排除打印等代码的中文文案（console.log, alert）
+                if (parent.type === 'CallExpression') {
+                    const callee = parent.callee;
+                    if ((callee.type === 'MemberExpression' &&
+                        callee.object.name === 'console') ||
+                        (callee.type === 'Identifier' && callee.name === 'alert')) {
+                        return;
+                    }
+                }
+                // 第二层：内容正则过滤（在 getChineseKey 中已包含）
+                const { key, isKey } = getChineseKey(path.node.value);
+                if (key) {
+                    if (parent.type === 'JSXAttribute') {
+                        if (isKey) {
+                            path.node.extra.raw = `'${key}'`;
+                        }
+                        else {
+                            path.node.extra.raw = `{${jsText}('${key}')}`;
+                        }
+                    }
+                    else {
+                        // 其他的jsx 基本就是直接替换
+                        if (isKey) {
+                            path.node.extra.raw = `'${key}'`;
+                        }
+                        else {
+                            path.node.extra.raw = `${jsText}('${key}')`;
+                        }
+                    }
+                    flag = true;
+                }
+            },
+            // 处理js 字符串模板的代码，我的测试${test}你在哪里啊？
+            TemplateLiteral(path) {
+                // 存储转换后的模板字符串和占位符对象
+                let transformedTemplate = '';
+                const placeholders = {};
+                let placeholderCounter = 0;
+                const rawTemplate = path.node.quasis.map((q) => q.value.raw).join('.{.*?}');
+                if (containsChinese(rawTemplate)) {
+                    // 遍历模板字符串的静态部分和插值表达式
+                    path.node.quasis.forEach((quasi, index) => {
+                        // 添加静态部分到转换后的模板字符串
+                        transformedTemplate += quasi.value.raw;
+                        // 如果当前不是最后一个元素，则添加插值表达式的占位符
+                        if (index < path.node.expressions.length) {
+                            // 生成唯一的占位符名称
+                            const placeholderName = `name${++placeholderCounter}`;
+                            // 添加占位符到转换后的模板字符串
+                            transformedTemplate += `{${placeholderName}}`;
+                            // 添加占位符对象，其键为占位符名称，值为插值表达式的源代码
+                            placeholders[placeholderName] = generate(path.node.expressions[index]).code;
+                        }
+                    });
+                    // 中文模板的不进行处理
+                    const { key, isKey } = getChineseKey(transformedTemplate);
+                    const regex = new RegExp('`' + rawTemplate + '`');
+                    const keyData = JSON.stringify(placeholders).replace(/"/g, '');
+                    if (isKey) {
+                        path.replaceWithSourceString(`'${key}&%&${keyData}'`);
+                    }
+                    else {
+                        path.replaceWithSourceString(`${jsText}('${key}',${keyData})`);
+                    }
+                    flag = true;
+                }
+            },
+            JSXElement(path) {
+                path.traverse({
+                    // 处理jsx中标签包含的文本
+                    JSXText(node) {
+                        const { key } = getChineseKey(node.node.value);
+                        if (key) {
+                            node.node.value = `{${jsText}('${key}')}`;
+                            flag = true;
+                        }
+                    },
+                });
+            },
+        });
+        // 是否有更新
+        if (flag) {
+            return generate(ast).code;
+        }
+    }
+    catch (error) {
+        console.warn('解析脚本文件出错:', error);
+        return undefined;
+    }
+}
+
+// 对拼接的字符串进行处理整理
+function concatenatedString(str, tempText) {
+    const strList = extractQuotedStrings(str);
+    if (!strList.length)
+        return;
+    if (strList.length) {
+        let strSource = str;
+        strList.forEach((item) => {
+            const { key } = getChineseKey(item.replace(/'|"/g, ''));
+            if (key) {
+                strSource = strSource.replace(item, `${tempText}('${key}')`);
+            }
+        });
+        return strSource;
+    }
+}
+// 提取 template 中的中文
+function extractChineseFromTemplate(content, tempText) {
+    if (!content) {
+        return;
+    }
+    let templateContent = content;
+    // 使用@vue/compiler-sfc来解析模板
+    const descriptor = compilerSfc.parse(`<template>${content}</template>`).descriptor;
+    // 获取模板的AST
+    const ast = descriptor.template?.ast;
+    if (!ast)
+        return content;
+    // 定义一个函数来递归遍历AST并收集所有文本节点和插值节点
+    // AST 逆向 template 存在者问题这里使用替换的方式进行处理
+    function extractNodes(node, source) {
+        // 这是中的类型 {{ }}, 事件，也就是模板解析的都在这里
+        if (node.type === 5 && containsChinese(node.content?.content)) {
+            const tempStr = extractTransformString(node.content.content);
+            if (tempStr) {
+                const { key } = getChineseKey(tempStr.key);
+                if (key) {
+                    const results = source.replace(node.content?.content.trim(), `${tempText}('${key}', { ${tempStr.data} })`);
+                    templateContent = templateContent.replace(source, results);
+                }
+            }
+            else {
+                const strSource = concatenatedString(node.content.content, tempText);
+                if (strSource) {
+                    const results = source.replace(node.content?.content.trim(), strSource);
+                    templateContent = templateContent.replace(source, results);
+                }
+            }
+        }
+        // 这是 TEXT 类型
+        if (node.type === 2) {
+            const { key } = getChineseKey(node.content);
+            if (key) {
+                const results = source.replace(node.content.trim(), `{{${tempText}('${key}')}}`);
+                templateContent = templateContent.replace(source, results);
+            }
+        }
+        if (node.children) {
+            let pstr = node.loc.source;
+            // 优先处理属性值
+            if (node?.props?.length) {
+                // 这里是处理属性值的地方
+                node.props.forEach((item) => {
+                    if (item.type === 6) {
+                        // 这个是纯的属性类型 title="我的测试"
+                        const { key } = getChineseKey(item?.value?.content);
+                        if (key) {
+                            pstr = pstr.replace(item.loc.source, `:${item.name}="${tempText}('${key}')"`);
+                        }
+                    }
+                    else if (item.type === 7 && item.exp?.content) {
+                        // 这里是一个bind 这里统一对 等号后面的字符串提取出来处理
+                        const strSource = concatenatedString(item.exp.content, tempText);
+                        if (strSource) {
+                            pstr = pstr.replace(item.exp.content, strSource);
+                        }
+                    }
+                });
+                templateContent = templateContent.replace(node.loc.source, pstr);
+            }
+            // 同级的children 值
+            node.children.forEach((item) => {
+                // res 修改的值就是父级的值，父级的 source
+                extractNodes(item, pstr);
+            });
+        }
+    }
+    // 检查 AST 的有效性
+    if (ast.children && ast.children.length > 0) {
+        ast.children.forEach((child) => {
+            extractNodes(child, ast.source);
+        });
+        return templateContent;
+    }
+    return content;
+}
+
+// 初始化全局变量
+globalThis.translationsMap = {};
+globalThis.addTranslations = [];
+globalThis.useTranslations = [];
+globalThis.keyLength = 16;
+function I18nAutoPlugin(options) {
+    let root = '';
+    let isPro = false;
+    // 配置
+    const configOption = {
+        ...options,
+        injectToJS: options.injectToJS ? `\n${options.injectToJS}\n` : `\nimport { useI18n } from 'vue-i18n'\nconst { t } = useI18n()\n`,
+        i18nPath: options.i18nPath || 'src/locales/zh-CN.ts',
+        langPath: options.langPath || ['src/locales/en.ts'],
+        regi18n: options.regi18n || 'useI18n',
+        excludes: options.excludes || ['locale', 'useI18n'],
+        tempText: options.tempText || 't',
+        jsText: options.jsText || 't',
+        delay: options.delay || 1000,
+        reserveKeys: options.reserveKeys || [],
+        runBuild: options.runBuild || false,
+        keyLength: options.keyLength || 16,
+        cryptoKey: options.cryptoKey || 'i18n',
+        preText: options.preText || '',
+    };
+    const dealWithLangFile = debounce((i18nPath) => {
+        updateJSONInFile(i18nPath, globalThis.translationsMap);
+    }, configOption.delay);
+    return {
+        name: 'i18n-auto-plugin', // 插件名称
+        enforce: 'pre', // 插件执行阶段（pre/normal/post）
+        configResolved(config) {
+            root = config.root;
+            isPro = config.isProduction;
+            globalThis.translationsMap = {};
+            globalThis.keyLength = configOption.keyLength;
+            globalThis.cryptoKey = configOption.cryptoKey;
+            globalThis.preText = configOption.preText;
+            if (!isPro) {
+                // 开发环境保留所有字段不进行任何的优化
+                const obj = getFileJson(path.resolve(root, configOption.i18nPath));
+                // 映射到全局之中去，反向映射出来
+                Object.keys(obj).forEach(key => {
+                    globalThis.translationsMap[key] = obj[key];
+                });
+            }
+            else if (configOption?.reserveKeys?.length) {
+                // 生产环境下对代码, 对保留的key 不进行处理的key进行了处理
+                const obj = getFileJson(path.resolve(root, configOption.i18nPath));
+                Object.keys(obj).forEach(key => {
+                    if (configOption.reserveKeys.includes(key)) {
+                        globalThis.translationsMap[key] = obj[key];
+                    }
+                });
+            }
+        },
+        transform(code, id) {
+            // 排除不需要处理的文件
+            if (configOption.excludes.some(i => id.includes(i)) ||
+                id.includes('node_modules') ||
+                id.includes('\x00') ||
+                id.includes('locales') || // 排除语言文件本身
+                !configOption.runBuild // 仅在 runBuild 为 true 时处理
+            ) {
+                return;
+            }
+            let rewrittenScript = code;
+            if (id.endsWith('.vue')) {
+                rewrittenScript = processVueFile(id, configOption) || code;
+            }
+            else if (['.ts', '.js', '.jsx', '.tsx'].some(i => id.split('?')[0].endsWith(i))) {
+                rewrittenScript = processJsFile(id, configOption);
+            }
+            const langFile = path.resolve(root, configOption.i18nPath);
+            if (!isPro && globalThis.addTranslations.length) {
+                dealWithLangFile(langFile);
+                globalThis.addTranslations = [];
+            }
+            // 始终返回转换后的代码（参考参考项目的实现）
+            return {
+                code: rewrittenScript,
+                map: null
+            };
+        },
+        buildEnd() {
+            // 打包构建的时候执行该代码, 这是打包阶段的了也是我们测试的时候使用
+            if (configOption.runBuild) {
+                const langFile = path.resolve(root, configOption.i18nPath);
+                // 这里整理所有的语言数据，所有的都是新的语言包，
+                updateJSONInFile(langFile, globalThis.translationsMap);
+                // 处理其他语言包的映射关系
+                if (configOption.langPath) {
+                    configOption.langPath.forEach(item => {
+                        const lf = path.resolve(root, item);
+                        const lm = getFileJson(lf);
+                        const obj = {};
+                        const endList = [];
+                        // 将未翻译的语言包也加入到最后
+                        Object.keys(globalThis.translationsMap).forEach(key => {
+                            if (lm[key]) {
+                                obj[key] = lm[key];
+                            }
+                            else {
+                                // 新增的key 直接加入到末尾
+                                endList.push({
+                                    key: key,
+                                    value: globalThis.translationsMap[key]
+                                });
+                            }
+                        });
+                        endList.forEach((item) => {
+                            obj[item.key] = item.value;
+                        });
+                        updateJSONInFile(lf, obj);
+                    });
+                }
+            }
+        }
+    };
+}
+function processJsFile(jsFilePath, options) {
+    const jsFileContent = fs.readFileSync(jsFilePath, 'utf-8');
+    let scriptTemp = extractChineseFromScript(jsFileContent, options.jsText);
+    if (scriptTemp) {
+        // 排除如果没有引入的值直接不处理
+        if (options.regi18n && !jsFileContent.includes(options.regi18n)) {
+            scriptTemp = `${options.injectToJS}${scriptTemp}`;
+        }
+        return scriptTemp;
+    }
+    return jsFileContent;
+}
+function processVueFile(vueFilePath, options) {
+    // 获取文件中的内容数据
+    let vueFileContent = fs.readFileSync(vueFilePath, 'utf-8');
+    // 使用 @vue/compiler-sfc 解析 Vue 文件
+    const { descriptor, errors } = compilerSfc.parse(vueFileContent);
+    // 如果解析时发生错误，打印错误信息
+    if (errors && errors.length) {
+        console.error('Errors occurred while parsing the Vue file:', vueFilePath);
+        return;
+    }
+    const vueTemplate = extractChineseFromTemplate(descriptor.template?.content || '', options.tempText);
+    if (vueTemplate && descriptor.template?.content) {
+        vueFileContent = vueFileContent.replace(descriptor.template.content, vueTemplate);
+    }
+    const dsScript = descriptor.script || descriptor.scriptSetup;
+    if (dsScript?.content) {
+        let scriptTemp = extractChineseFromScript(dsScript.content, options.jsText);
+        if (scriptTemp) {
+            // 这里对字符串进行判断是否要注入js在里面, 如果文本没有修改
+            if (options.regi18n && !scriptTemp.includes(options.regi18n)) {
+                scriptTemp = `${options.injectToJS}${scriptTemp}`;
+            }
+            vueFileContent = vueFileContent.replace(dsScript.content, scriptTemp);
+        }
+        else if (vueTemplate !== descriptor.template?.content) {
+            // 这里对字符串进行判断是否要注入js在里面, 如果文本没有修改
+            let strcontent = dsScript.content;
+            if (options.regi18n && !strcontent.includes(options.regi18n)) {
+                strcontent = `${options.injectToJS}${strcontent}`;
+            }
+            vueFileContent = vueFileContent.replace(dsScript.content, strcontent);
+        }
+    }
+    return vueFileContent;
+}
+
+module.exports = I18nAutoPlugin;
+//# sourceMappingURL=index.cjs.js.map