vue-i18n-extract-plugin 1.0.47

package/lib/index.js

@@ -0,0 +1,74 @@
+const babelPluginI18n = require("./babel-plugin-i18n");
+const { extractI18n, addI18nImportIfNeeded } = require("./extract");
+const { defaultOptions } = require("./options");
+const {
+  autoTranslate,
+  translateChunks,
+  createTextSplitter,
+  getLangJsonPath
+} = require("./translate");
+const translators = require("./translators");
+const {
+  hashKey,
+  generateId,
+  parseArg,
+  checkAgainstRegexArray,
+  extractFunctionName,
+  relativeCWDPath,
+  shouldExtract,
+  trimEmptyLine,
+  padEmptyLine,
+  excludeDirectives,
+  EXCLUDED_CALL
+} = require("./utils");
+const {
+  shouldTransform,
+  isTFunction,
+  createI18nVisitor,
+  createI18nPlugin
+} = require("./visitors");
+const vitePluginI18n = require("./vite-plugin-i18n");
+const vitePluginImportI18n = require("./vite-plugin-import-i18n");
+const WebpackPluginI18n = require("./webpack-plugin-i18n");
+const vueI18nLoader = require("./vue-i18n-loader");
+const babelPluginImportI18n = require("./babel-plugin-import-i18n");
+const {
+  i18nImportAstTransform,
+  i18nImportTransform,
+  extractScriptContent
+} = require("./import-i18n-transform");
+
+module.exports = {
+  babelPluginI18n,
+  extractI18n,
+  defaultOptions,
+  translators,
+  autoTranslate,
+  translateChunks,
+  createTextSplitter,
+  getLangJsonPath,
+  hashKey,
+  generateId,
+  parseArg,
+  checkAgainstRegexArray,
+  extractFunctionName,
+  relativeCWDPath,
+  shouldExtract,
+  trimEmptyLine,
+  padEmptyLine,
+  excludeDirectives,
+  EXCLUDED_CALL,
+  shouldTransform,
+  isTFunction,
+  addI18nImportIfNeeded,
+  createI18nVisitor,
+  createI18nPlugin,
+  vitePluginI18n,
+  vitePluginImportI18n,
+  WebpackPluginI18n,
+  vueI18nLoader,
+  babelPluginImportI18n,
+  i18nImportAstTransform,
+  i18nImportTransform,
+  extractScriptContent
+};

package/lib/options.js

@@ -0,0 +1,39 @@
+const { GoogleTranslator } = require("./translators");
+
+const defaultOptions = {
+  translateKey: "$t", // 提取的函数的名称
+  rewrite: true, // 是否将提取到的内容转换为id后重写入源文件
+  extractFromText: true, // 是否允许从纯文本节点中提取翻译内容
+  autoImportI18n: true, // 是否自动导入 i18n 模块
+  autoTranslate: true, // 提取完成后是否自动翻译
+  cleanTranslate: true, // 是否清理无用的翻译内容
+  enableExtractInPlugin: true, // 是否在插件中自动提取翻译内容
+  outputJsonFileInPlugin: true, // 是否在插件中输出 JSON 文件
+  outputJsonFileDebounceTimeInPlugin: 2000, // 输出 JSON 文件的防抖时间
+  translateInterval: 1000, // 自动翻译的间隔时间
+  excludedCall: [], // 排除的调用函数名称数组
+  includePath: ["src/"], // 包含路径的数组
+  excludedPath: [], // 排除路径的数组
+  allowedExtensions: [".vue", ".tsx", ".ts", ".jsx", ".js"], // 允许提取的文件扩展名
+  fromLang: "zh-cn", // 源语言, 目前支持提取的语言有：zh-cn(zh-tw), en, ja, ko, ru
+  translateLangKeys: ["zh-tw", "en"], // 需要翻译为的语言键
+  i18nPkgImportPath: "@/i18n", // i18n语言包导入路径
+  outputPath: "src/i18n", // 提取的语言包输出文件路径
+  customGenLangFileName: langKey => langKey, // 自定义生成语言文件名
+  // 翻译后的文本处理函数，方便对翻译后的文本进行二次加工，如每个单词首字母大写, params: text: 翻译后的文本, toLang: 翻译后的目标语言，translateLangKeys的枚举成员
+  customTranslatedText: (text, toLang) => text,
+  /** 翻译器，决定自动翻译使用的api与调用方式，默认使用 Google 翻译器并使用7890(clash)端口代理 */
+  translator: new GoogleTranslator({
+    // proxyOption: {
+    //     port: 7890,
+    //     host: '127.0.0.1',
+    //     headers: {
+    //         'User-Agent': 'Node'
+    //     }
+    // }
+  })
+};
+
+module.exports = {
+  defaultOptions
+};

package/lib/translate.js

@@ -0,0 +1,308 @@
+const fs = require("fs-extra");
+const {
+  isEmptyObject,
+  getLangJsonPath,
+  readJsonWithDefault,
+  sleep
+} = require("./utils");
+const { defaultOptions } = require("./options");
+
+const SEPARATOR = "\n┇┇┇\n";
+const SPLIT_SEPARATOR_REGEX = /\n┇ *┇ *┇\n/;
+
+/**
+ * 智能文本分块处理器
+ * @param values 待分块的原始文本数组
+ * @param maxChunkSize 最大分块长度
+ * @returns 包含分块文本和重组方法的对象
+ *
+ * 功能特性：
+ * 1. 自动合并小文本为最大可能块
+ * 2. 处理超长文本并给出警告
+ * 3. 保证块长度不超过限制
+ * 4. 保留原始顺序和分隔符语义
+ */
+function createTextSplitter(values, maxChunkSize) {
+  // 分隔符定义（用于合并/拆分时保持语义）
+  const SEP_LENGTH = SEPARATOR.length;
+
+  // 结果存储和缓冲区
+  const result = []; // 最终分块结果
+  let buffer = []; // 当前累积块缓冲区
+  let currentSize = 0; // 当前缓冲区字符数（含分隔符）
+
+  /**
+   * 提交缓冲区内容到结果集
+   * - 将缓冲区内容用分隔符连接
+   * - 重置缓冲区和计数器
+   */
+  const commitBuffer = () => {
+    if (buffer.length > 0) {
+      // 计算实际连接长度用于验证
+      const actualLength = buffer.join(SEPARATOR).length;
+      if (actualLength > maxChunkSize) {
+        console.warn(`缓冲区提交异常：生成块长度 ${actualLength} 超过限制`);
+      }
+
+      result.push(buffer.join(SEPARATOR));
+      buffer = [];
+      currentSize = 0;
+    }
+  };
+
+  // 主处理循环：遍历所有原始文本项
+  for (const value of values) {
+    // 计算需要新增的空间：文本长度 + 分隔符（非首项）
+    const neededSpace = value.length + (buffer.length > 0 ? SEP_LENGTH : 0);
+
+    // ─── 超长文本处理策略 ───
+    if (value.length > maxChunkSize) {
+      // 优先提交现有缓冲区内容
+      if (buffer.length > 0) commitBuffer();
+
+      /**
+       * 超长文本处理逻辑：
+       * - 长度超过1.5倍限制时发出强警告
+       * - 强制单独成块（即使超过限制）
+       * - 后续需要特殊处理这些异常块
+       */
+      if (value.length > maxChunkSize * 1.5) {
+        console.warn(
+          `超长文本告警：检测到长度 ${value.length} 字符的文本项，可能影响翻译质量`
+        );
+      }
+      // 结果直接新增一个超长文本
+      result.push(value);
+      continue;
+    }
+
+    // ─── 正常分块逻辑 ───
+    // 空间不足时提交当前缓冲区
+    if (currentSize + neededSpace > maxChunkSize) {
+      commitBuffer();
+    }
+
+    // 更新缓冲区状态（累加长度需包含分隔符）
+    currentSize += neededSpace;
+    buffer.push(value);
+  }
+
+  // 提交最终未完成的缓冲区内容
+  commitBuffer();
+
+  // 返回分块结果
+  return result;
+}
+
+function getI18nObjByLangKey(langKey, option) {
+  const langJsonPath = getLangJsonPath(langKey, option);
+  return readJsonWithDefault(langJsonPath, {});
+}
+
+function valuesToObject(values, keys) {
+  const obj = {};
+  for (let i = 0; i < keys.length; i++) {
+    obj[keys[i]] = values[i];
+  }
+  return obj;
+}
+
+function cleanI18nMap(sourceObj, targetObj) {
+  const result = {};
+  Object.keys(targetObj).forEach(key => {
+    if (sourceObj[key]) {
+      result[key] = targetObj[key];
+    }
+  });
+  return result;
+}
+
+async function autoTranslateFromFile() {
+  const fromLangMap = readJsonWithDefault(
+    getLangJsonPath(defaultOptions.fromLang, defaultOptions),
+    null
+  );
+  if (!fromLangMap) {
+    console.warn(
+      `❌ 源语言文件 ${defaultOptions.fromLang}.json 为空，请先添加源语言内容`
+    );
+    return;
+  }
+
+  autoTranslate(fromLangMap);
+}
+
+async function autoTranslate(i18nMap, option) {
+  option = { ...defaultOptions, ...option };
+  // 初始化现有翻译文件缓存
+  const langObjMap = {};
+  //  待翻译语言缓存
+  const toTransLangObjMap = {};
+
+  // 加载所有语言的现有翻译内容
+  option.translateLangKeys.forEach(langKey => {
+    langObjMap[langKey] = getI18nObjByLangKey(langKey, option);
+    toTransLangObjMap[langKey] = {};
+  });
+
+  // 比对出需要翻译的key
+  Object.keys(i18nMap).forEach(i18nKey => {
+    option.translateLangKeys.forEach(langKey => {
+      if (langObjMap[langKey] && !langObjMap[langKey][i18nKey]) {
+        toTransLangObjMap[langKey][i18nKey] = i18nMap[i18nKey];
+      }
+    });
+  });
+
+  // 遍历所有目标语言进行处理
+  for (const langKey of Object.keys(toTransLangObjMap)) {
+    const curLangObj = toTransLangObjMap[langKey];
+    const curLangKeys = Object.keys(curLangObj);
+
+    if (curLangKeys.length === 0) {
+      console.info(`${langKey}无需翻译，跳过...`);
+      continue;
+    }
+
+    console.info(
+      `[${option.translator.option.name}] 开始自动翻译${langKey}...`
+    );
+
+    // ─── 分块翻译流程开始 ───
+    const translatedValues = await translateChunks(curLangObj, langKey, option);
+    // ─── 分块翻译流程结束 ───=
+
+    // ─── 翻译结果校验 ───
+    if (translatedValues.length !== curLangKeys.length) {
+      console.error(
+        "❌ 使用付费翻译时，请检查翻译API额度是否充足，或是否已申请对应翻译API使用权限"
+      );
+      console.error(`❌ ${langKey}翻译结果不完整
+                预期数量: ${curLangKeys.length}
+                实际数量: ${translatedValues.length}
+                样例数据: ${JSON.stringify(translatedValues.slice(0, 3))}`);
+      // return;
+    }
+
+    // 存储当前语言翻译结果
+    toTransLangObjMap[langKey] = valuesToObject(translatedValues, curLangKeys);
+    console.info(`✅ ${langKey} 翻译完成`);
+
+    // 设置翻译每种语言的间隔时间，防止被墙
+    await sleep(option.translateInterval);
+  }
+
+  // ─── 合并翻译结果到配置 ───
+  for (const langKey of Object.keys(toTransLangObjMap)) {
+    if (!isEmptyObject(toTransLangObjMap[langKey])) {
+      try {
+        const mergedLangObj = Object.assign(
+          langObjMap[langKey],
+          toTransLangObjMap[langKey]
+        );
+        // ─── 写入文件系统 ───
+        await fs.outputJson(getLangJsonPath(langKey, option), mergedLangObj, {
+          spaces: 2
+        });
+        console.info(`🎉 ${langKey} 配置文件已成功更新`);
+      } catch (error) {
+        console.error(`❌ ${langKey} 配置文件写入失败，原因:`, error);
+      }
+    }
+  }
+}
+
+// 清理无用的翻译（以源语言作对照）
+async function cleanTranslate(option) {
+  option = { ...defaultOptions, ...option };
+  // 初始化现有翻译文件缓存
+  const langObjMap = {};
+  const fromLangI18nMap = getI18nObjByLangKey(option.fromLang, option);
+
+  // 加载所有语言的现有翻译内容
+  option.translateLangKeys.forEach(langKey => {
+    const currentLangI18nMap = getI18nObjByLangKey(langKey, option);
+    const cleanedI18nMap = cleanI18nMap(fromLangI18nMap, currentLangI18nMap);
+    if (
+      Object.keys(cleanedI18nMap).length !==
+      Object.keys(currentLangI18nMap).length
+    ) {
+      langObjMap[langKey] = cleanedI18nMap;
+    }
+  });
+
+  // 将清理后的语言对象写入文件
+  for (const langKey of Object.keys(langObjMap)) {
+    await fs.outputJson(getLangJsonPath(langKey, option), langObjMap[langKey], {
+      spaces: 2
+    });
+    console.info(`🎉 ${langKey} 配置文件清理成功`);
+  }
+}
+
+// 分块翻译流程函数
+async function translateChunks(transLangObj, toTranslateLang, option) {
+  const { translator } = option;
+  // 获取分块后的文本列表
+  const translationChunks = createTextSplitter(
+    Object.values(transLangObj),
+    translator.option.maxChunkSize
+  );
+  // 并行执行分块翻译
+  const translatePromises = [];
+  for (let i = 0; i < translationChunks.length; i++) {
+    translatePromises.push(
+      translator.translate(
+        translationChunks[i],
+        option.fromLang,
+        toTranslateLang,
+        SEPARATOR
+      )
+    );
+  }
+
+  // 等待所有分块完成并合并结果
+  const chunkResults = await Promise.all(translatePromises);
+  const customTranslatedText =
+    typeof option.customTranslatedText !== "function"
+      ? text => text
+      : option.customTranslatedText;
+
+  return chunkResults
+    .map(item => {
+      // 提取分割逻辑到单独的函数中，提高代码复用性
+      const splitTranslation = (text, separatorRegex) => {
+        return text
+          .split(separatorRegex)
+          .map(v => customTranslatedText(v.trim(), toTranslateLang));
+      };
+
+      // 分割符可能会被翻译，所以这里做了兼容处理
+      if (SPLIT_SEPARATOR_REGEX.test(item)) {
+        return splitTranslation(item, SPLIT_SEPARATOR_REGEX);
+      } else {
+        const lines = item.split("\n");
+        const separator = lines.find(line => line.length === 3);
+        let value = [];
+        if (separator) {
+          value = splitTranslation(item, new RegExp(`\\n${separator}\\n`));
+        }
+        const realList = value.filter(Boolean);
+        if (realList.length > 1) {
+          return realList;
+        }
+        return splitTranslation(item, SPLIT_SEPARATOR_REGEX);
+      }
+    })
+    .flat();
+}
+
+module.exports = {
+  autoTranslateFromFile,
+  autoTranslate,
+  cleanTranslate,
+  translateChunks,
+  createTextSplitter,
+  getLangJsonPath,
+  cleanI18nMap
+};

package/lib/translators/baidu.js

@@ -0,0 +1,91 @@
+const axios = require("axios");
+const { Translator } = require("./translator");
+const CryptoJS = require("crypto-js");
+
+/**
+ * 百度翻译器
+ * 
+ * api文档：https://api.fanyi.baidu.com/product/113
+ * 
+ * 使用方式：
+ * ```ts
+ * vitePluginI18n({
+    ...
+    translator: new BaiduTranslator({
+        appId: '你申请的appId',
+        appKey: '你申请的appKey'
+    })
+})
+ * ```
+ */
+class BaiduTranslator extends Translator {
+  /** 百度的语言类型映射不标准，需要手动控制 */
+  BAIDU_TRANSLATE_KEY_CONVERT_MAP = {
+    "zh-cn": "zh",
+    "zh-tw": "cht",
+    ja: "jp",
+    ko: "kor"
+  };
+
+  getTranslateKey(key) {
+    return this.BAIDU_TRANSLATE_KEY_CONVERT_MAP[key] || key;
+  }
+
+  constructor(option = {}) {
+    super({
+      name: "百度翻译",
+      fetchMethod: async (text, fromKey, toKey, separator) => {
+        let salt = new Date().getTime();
+
+        const data = {
+          q: text,
+          appid: option.appId,
+          from: this.getTranslateKey(fromKey),
+          to: this.getTranslateKey(toKey),
+          salt,
+          sign: CryptoJS.MD5(
+            option.appId + text + salt + option.appKey
+          ).toString()
+        };
+        const response = await axios.post(
+          "https://fanyi-api.baidu.com/api/trans/vip/translate",
+          data,
+          {
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+            },
+            proxy: option.proxy
+          }
+        );
+
+        const { error_code, error_msg, trans_result } = response.data || {};
+
+        if (error_code) {
+          console.error(
+            `❌ 百度翻译错误：${error_code} - ${error_msg}，请检查你的 appId 和 appKey 是否正确。`
+          );
+          return "";
+        }
+
+        const translatedTexts = trans_result
+          .map(item => item.dst)
+          .filter((_item, index) => index % 2 === 0)
+          .join(separator);
+
+        // 请求成功，返回响应数据
+        return translatedTexts || "";
+      },
+      onError: (error, cb) => {
+        cb(error);
+        console.error(
+          "请前往百度翻译官方申请翻译key，每个月都有免费额度，并请检查额度是否充足。"
+        );
+      },
+      interval: option.interval ?? 1000
+    });
+  }
+}
+
+module.exports = {
+  BaiduTranslator
+};

package/lib/translators/google.js

@@ -0,0 +1,68 @@
+const { translate } = require("@vitalets/google-translate-api");
+const { Translator } = require("./translator");
+const tunnel = require("tunnel");
+
+/**
+ * 谷歌翻译器
+ * 
+ * 基于@vitalets/google-translate-api，需要翻墙，不稳定，但是免费
+ * 
+ * 使用方式：
+ * ```ts
+ * vitePluginI18n({
+    ...
+    translator: translator: new GoogleTranslator({
+        proxyOption: {
+            // 如果你本地的代理在127.0.0.0:8899
+            host: '127.0.0.1',
+            port: 8899,
+            headers: {
+                'User-Agent': 'Node'
+            }
+        }
+    })
+})
+ * ```
+ */
+class GoogleTranslator extends Translator {
+  constructor(option = {}) {
+    super({
+      name: "Google翻译",
+      fetchMethod: async (text, fromKey, toKey, separator) => {
+        let data = await translate(text, {
+          from: fromKey,
+          to: toKey,
+          ...(option.proxyOption
+            ? {
+                fetchOptions: {
+                  agent: tunnel.httpsOverHttp({
+                    proxy: option.proxyOption
+                  })
+                }
+              }
+            : {})
+        });
+        const result = data["text"] || "";
+        if (separator && toKey === "th") {
+          return result.replace(/\n\n/g, separator);
+        }
+        return result;
+      },
+      onError: (error, cb) => {
+        cb(error);
+        if (
+          error instanceof Object &&
+          "code" in error &&
+          error.code === "ETIMEDOUT"
+        ) {
+          console.error("❗ 请求超时，请确保你的网络可以访问google ❗");
+        }
+      },
+      interval: option.interval ?? 1000
+    });
+  }
+}
+
+module.exports = {
+  GoogleTranslator
+};

package/lib/translators/index.js

@@ -0,0 +1,15 @@
+const { Translator } = require("./translator");
+const { GoogleTranslator } = require("./google");
+const { YoudaoTranslator } = require("./youdao");
+const { BaiduTranslator } = require("./baidu");
+const { EmptyTranslator } = require("./scan");
+const { VolcEngineTranslator } = require("./volcengine");
+
+module.exports = {
+  Translator,
+  GoogleTranslator,
+  YoudaoTranslator,
+  BaiduTranslator,
+  EmptyTranslator,
+  VolcEngineTranslator
+};

package/lib/translators/scan.js

@@ -0,0 +1,24 @@
+const { Translator } = require("./translator");
+
+/**
+ * 空翻译器，不翻译文本，用于配合某些特殊的操作
+ */
+class EmptyTranslator extends Translator {
+  constructor(option = {}) {
+    const resultOption = {
+      name: "空翻译器",
+      fetchMethod: async (text, _from, _to, separator) => {
+        // 相当于把翻译结果统一设置为空串
+        const value = text.split(separator).fill("");
+        return value.join(separator);
+      },
+      ...option
+    };
+    super(resultOption);
+  }
+  // TODO: 后续可以作为基类，提供更多的配置选项
+}
+
+module.exports = {
+  EmptyTranslator
+};

package/lib/translators/translator/IntervalQueue.js

@@ -0,0 +1,60 @@
+/**
+ * 间隔执行队列
+ */
+class IntervalQueue {
+  queue = [];
+  isRunning = false;
+
+  /**
+   * @param fn 执行函数
+   * @param delay 执行间隔
+   * @param timeout 超时时间
+   */
+  constructor(fn, delay, timeout) {
+    this.fn = fn;
+    this.delay = delay;
+    this.timeout = timeout;
+  }
+
+  async wait(delay = this.delay) {
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+
+  async run() {
+    if (this.isRunning) return;
+    let item;
+    while ((item = this.queue.shift())) {
+      const { args, resolve, reject } = item;
+      this.isRunning = true;
+      try {
+        const result = await this.fn(...args);
+        resolve(result);
+      } catch (e) {
+        reject(e);
+      }
+      await this.wait();
+    }
+    this.isRunning = false;
+  }
+
+  /**
+   * 执行一次fn
+   * @param args fn的入参
+   * @returns 返回fn的返回值的Promise
+   */
+  execute(...args) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ args, resolve, reject });
+      this.run();
+      if (this.timeout) {
+        setTimeout(() => {
+          reject(new Error("IntervalQueue timeout"));
+        }, this.timeout);
+      }
+    });
+  }
+}
+
+module.exports = {
+  IntervalQueue
+};