vue-i18n-extract-plugin 1.0.47 → 1.0.49

package/README.md

@@ -48,12 +48,12 @@ extractI18n(options)
 ```javascript
 const defaultOptions = {
   translateKey: "$t", // 提取的函数的名称
-  rewrite: true, // 是否将提取到的内容转换为id后重写入源文件
+  rewrite: false, // 是否将提取到的内容转换为id后重写入源文件
   extractFromText: true, // 是否允许从纯文本节点中提取翻译内容
   autoImportI18n: true, // 是否自动导入 i18n 模块
   autoTranslate: true, // 提取完成后是否自动翻译
   cleanTranslate: true, // 是否清理无用的翻译内容
-  enableExtractInPlugin: true, // 是否在插件中自动提取翻译内容
+  enabled: true, // 是否启用插件
   outputJsonFileInPlugin: true, // 是否在插件中输出 JSON 文件
   outputJsonFileDebounceTimeInPlugin: 2000, // 输出 JSON 文件的防抖时间
   translateInterval: 1000, // 自动翻译的间隔时间
@@ -109,10 +109,10 @@ import { vitePluginImportI18n, vitePluginI18n } from "vue-i18n-extract-plugin";
 
 export default defineConfig({
   plugins: [
-    // 自动添加import { $t } from '@/i18n'导入语句，请在i18n文件导出一个$t的方法. 注意顺序，必放在vue插件之前
+    // 自动添加import { $t } from '@/i18n'导入语句，请在i18n文件导出一个$t的方法.
     vitePluginImportI18n(options),
     vue(),
-    // 用于运行时转换. 注意顺序，必放在vue插件之后
+    // 用于运行时转换
     vitePluginI18n(options)
   ]
 });

package/lib/babel-plugin-i18n.js

@@ -6,6 +6,13 @@ module.exports = declare((api, options) => {
   api.assertVersion(7);
   options = { ...defaultOptions, ...options };
 
+  if (!options.enabled) {
+    return {
+      name: "i18n-hash-replace",
+      visitor: {}
+    };
+  }
+
   return {
     name: "i18n-hash-replace",
     ...createI18nPlugin(options)()

package/lib/babel-plugin-import-i18n.js

@@ -6,11 +6,17 @@ module.exports = function () {
     name: "auto-import-i18n",
     visitor: {
       Program(path, state) {
-        const { translateKey: importName, i18nPkgImportPath: importPath } = {
+        const {
+          translateKey: importName,
+          i18nPkgImportPath: importPath,
+          enabled
+        } = {
           ...defaultOptions,
           ...state.opts
         };
 
+        if (!enabled) return;
+
         const localName = importName;
         let hasI18nImport = false;
         let lastImportPath = null;

package/lib/cli.js

@@ -38,7 +38,7 @@ const cli = async function (args) {
     name: Object.keys(bin)[0]
   });
 
-  options = Object.assign({ rewrite: false }, configFromFile, options);
+  options = Object.assign({}, configFromFile, options);
 
   console.log("开始提取国际化内容...\n", options);
 

package/lib/index.js

@@ -4,8 +4,7 @@ const { defaultOptions } = require("./options");
 const {
   autoTranslate,
   translateChunks,
-  createTextSplitter,
-  getLangJsonPath
+  createTextSplitter
 } = require("./translate");
 const translators = require("./translators");
 const {
@@ -15,6 +14,7 @@ const {
   checkAgainstRegexArray,
   extractFunctionName,
   relativeCWDPath,
+  getLangJsonPath,
   shouldExtract,
   trimEmptyLine,
   padEmptyLine,

package/lib/options.js

@@ -2,12 +2,12 @@ const { GoogleTranslator } = require("./translators");
 
 const defaultOptions = {
   translateKey: "$t", // 提取的函数的名称
-  rewrite: true, // 是否将提取到的内容转换为id后重写入源文件
+  rewrite: false, // 是否将提取到的内容转换为id后重写入源文件
   extractFromText: true, // 是否允许从纯文本节点中提取翻译内容
   autoImportI18n: true, // 是否自动导入 i18n 模块
   autoTranslate: true, // 提取完成后是否自动翻译
   cleanTranslate: true, // 是否清理无用的翻译内容
-  enableExtractInPlugin: true, // 是否在插件中自动提取翻译内容
+  enabled: true, // 是否启用插件
   outputJsonFileInPlugin: true, // 是否在插件中输出 JSON 文件
   outputJsonFileDebounceTimeInPlugin: 2000, // 输出 JSON 文件的防抖时间
   translateInterval: 1000, // 自动翻译的间隔时间

package/lib/translate.js

@@ -303,6 +303,5 @@ module.exports = {
   cleanTranslate,
   translateChunks,
   createTextSplitter,
-  getLangJsonPath,
   cleanI18nMap
 };

package/lib/visitors.js

@@ -44,6 +44,8 @@ function createI18nVisitor(option, i18nMap) {
         keyText = firstArg.quasis.map(q => q.value.cooked).join("${}");
       }
 
+      keyText = keyText.trim();
+
       if (!keyText) return;
 
       if (!shouldExtract(keyText, option.fromLang)) {
@@ -58,10 +60,8 @@ function createI18nVisitor(option, i18nMap) {
         i18nMap[hashed] = keyText;
       }
 
-      if (option.rewrite) {
-        const newArg = t.stringLiteral(hashed);
-        path.node.arguments[0] = newArg;
-      }
+      const newArg = t.stringLiteral(hashed);
+      path.node.arguments[0] = newArg;
     },
 
     StringLiteral(path) {
@@ -91,7 +91,7 @@ function createI18nVisitor(option, i18nMap) {
         return;
       }
 
-      const value = path.node.value;
+      const value = path.node.value.trim();
 
       // const callExpr = path.findParent((p) => p.isCallExpression());
 
@@ -100,8 +100,7 @@ function createI18nVisitor(option, i18nMap) {
       //   return;
       // }
 
-      if (value.trim() === "") return;
-      if (!shouldExtract(value, option.fromLang)) {
+      if (!value || !shouldExtract(value, option.fromLang)) {
         return;
       }
 
@@ -113,29 +112,27 @@ function createI18nVisitor(option, i18nMap) {
         i18nMap[hashed] = value;
       }
 
-      if (option.rewrite) {
-        const callExpression = t.callExpression(
-          t.identifier(option.translateKey),
-          [t.stringLiteral(hashed)]
-        );
-        // 如果是 JSX 属性值，需要包裹在 JSXExpressionContainer 中
-        if (parentPath.isJSXAttribute()) {
-          const jsxExpression = t.jsxExpressionContainer(callExpression);
-          path.replaceWith(jsxExpression);
-        } else {
-          // 其他情况直接替换
-          path.replaceWith(callExpression);
-        }
+      const callExpression = t.callExpression(
+        t.identifier(option.translateKey),
+        [t.stringLiteral(hashed)]
+      );
+      // 如果是 JSX 属性值，需要包裹在 JSXExpressionContainer 中
+      if (parentPath.isJSXAttribute()) {
+        const jsxExpression = t.jsxExpressionContainer(callExpression);
+        path.replaceWith(jsxExpression);
+      } else {
+        // 其他情况直接替换
+        path.replaceWith(callExpression);
       }
     },
 
     TemplateElement(path) {
-      const { node, parent } = path;
+      const { node } = path;
       if (!node.value) return;
 
-      let value = node.value.raw || node.value.cooked;
+      let value = (node.value.raw || node.value.cooked).trim();
 
-      if (value.trim() === "") return;
+      if (!value) return;
 
       // 获取真实调用函数
       const extractFnName = extractFunctionName(path);
@@ -163,11 +160,9 @@ function createI18nVisitor(option, i18nMap) {
         i18nMap[hashed] = value;
       }
 
-      if (option.rewrite) {
-        // 替换为字符类型翻译节点
-        const tCallExpression = `${option.translateKey}('${hashed}')`;
-        node.value.raw = node.value.cooked = `\${${tCallExpression}}`;
-      }
+      // 替换为字符类型翻译节点
+      const tCallExpression = `${option.translateKey}('${hashed}')`;
+      node.value.raw = node.value.cooked = `\${${tCallExpression}}`;
     },
     JSXText(path) {
       // <div>Hello world</div>
@@ -188,43 +183,43 @@ function createI18nVisitor(option, i18nMap) {
         i18nMap[hashed] = text;
       }
 
-      if (option.rewrite) {
-        // 替换为表达式 {$t("hashed")}
-        path.replaceWith(
-          t.jsxExpressionContainer(
-            t.callExpression(t.identifier(option.translateKey), [
-              t.stringLiteral(hashed)
-            ])
-          )
-        );
-      }
+      // 替换为表达式 {$t("hashed")}
+      path.replaceWith(
+        t.jsxExpressionContainer(
+          t.callExpression(t.identifier(option.translateKey), [
+            t.stringLiteral(hashed)
+          ])
+        )
+      );
     },
     JSXExpressionContainer(path) {
       // <div>{"Hi"}</div>
       if (option.extractFromText === false) return;
       const expr = path.node.expression;
+
       if (t.isStringLiteral(expr)) {
-        if (!shouldExtract(expr.value, option.fromLang)) {
+        const value = expr.value.trim();
+
+        if (!value) return;
+        if (!shouldExtract(value, option.fromLang)) {
           return;
         }
 
         // console.log("JSXExpressionContainer", path.node.expression.expr);
 
-        const hashed = generateId(expr.value);
+        const hashed = generateId(value);
 
         if (i18nMap) {
-          i18nMap[hashed] = expr.value;
+          i18nMap[hashed] = value;
         }
 
-        if (option.rewrite) {
-          path.replaceWith(
-            t.jsxExpressionContainer(
-              t.callExpression(t.identifier(option.translateKey), [
-                t.stringLiteral(hashed)
-              ])
-            )
-          );
-        }
+        path.replaceWith(
+          t.jsxExpressionContainer(
+            t.callExpression(t.identifier(option.translateKey), [
+              t.stringLiteral(hashed)
+            ])
+          )
+        );
       }
     }
   };

package/lib/vite-plugin-i18n.js

@@ -1,6 +1,6 @@
 const { transformAsync } = require("@babel/core");
 const { createI18nPlugin } = require("./visitors");
-const { checkAgainstRegexArray } = require("./utils");
+const { relativeCWDPath, checkAgainstRegexArray } = require("./utils");
 const { defaultOptions } = require("./options");
 const { globalI18nMap, handleFinalI18nMap } = require("./extract");
 
@@ -12,12 +12,36 @@ function vitePluginI18n(option) {
 
   return {
     name: "vite-plugin-i18n-hash",
+    enforce: "post",
+    config(config, { command }) {
+      if (command !== "serve") return null;
+      const existingServerConfig = config.server || {};
+      const existingWatchConfig = existingServerConfig.watch || {};
+      const existingIgnored = existingWatchConfig.ignored || [];
+      const newIgnored = relativeCWDPath(option.outputPath) + "**";
 
+      const ignored = [
+        ...(Array.isArray(existingIgnored)
+          ? existingIgnored
+          : [existingIgnored]),
+        ...(Array.isArray(newIgnored) ? newIgnored : [newIgnored])
+      ].filter(Boolean);
+
+      return {
+        server: {
+          ...existingServerConfig,
+          watch: {
+            ...existingWatchConfig,
+            ignored
+          }
+        }
+      };
+    },
     configResolved(resolvedConfig) {
       config = resolvedConfig;
     },
     async transform(code, path) {
-      if (!option.enableExtractInPlugin) return;
+      if (!option.enabled) return;
 
       if (option.allowedExtensions.some(ext => path.endsWith(ext))) {
         if (

package/lib/vite-plugin-import-i18n.js

@@ -9,7 +9,8 @@ function vitePluginImportI18n(options) {
     i18nPkgImportPath: importPath,
     allowedExtensions: extensions,
     includePath,
-    excludedPath
+    excludedPath,
+    enabled
   } = { ...defaultOptions, ...options };
 
   const filter = createFilter(
@@ -37,7 +38,7 @@ function vitePluginImportI18n(options) {
     name: "vite-plugin-import-i18n",
     enforce: "pre",
     async transform(code, path) {
-      if (!filter(path)) return;
+      if (!enabled || !filter(path)) return;
       return i18nImportTransform(code, path, importName, importPath);
     }
   };

package/lib/webpack-plugin-i18n.js

@@ -27,6 +27,7 @@ class WebpackPluginI18n {
    * @param compiler Webpack 编译器实例
    */
   apply(compiler) {
+    if (!this.options.enabled) return;
     /**
      * 检查是否已经添加过这个自定义 Loader，避免重复添加
      * @param rule Webpack 模块规则
@@ -49,22 +50,21 @@ class WebpackPluginI18n {
         !compiler.options.module.rules.some(hasCustomLoader)
       ) {
         const loaderRegex = generateAdvancedRegex(this.options);
-        if (this.options.enableExtractInPlugin) {
-          // 向 module.rules 中添加自定义 Loader
-          compiler.options.module?.rules.push({
-            // 生成高级正则表达式，用于匹配目标文件
-            test: loaderRegex,
-            // 设置 Loader 执行顺序为后置
-            enforce: "post",
-            use: [
-              {
-                // 指定自定义 Loader 的路径
-                loader: path.resolve(__dirname, "./vue-i18n-loader.js"),
-                options: this.options
-              }
-            ]
-          });
-        }
+
+        // 向 module.rules 中添加自定义 Loader
+        compiler.options.module?.rules.push({
+          // 生成高级正则表达式，用于匹配目标文件
+          test: loaderRegex,
+          // 设置 Loader 执行顺序为后置
+          enforce: "post",
+          use: [
+            {
+              // 指定自定义 Loader 的路径
+              loader: path.resolve(__dirname, "./vue-i18n-loader.js"),
+              options: this.options
+            }
+          ]
+        });
 
         if (this.options.autoImportI18n) {
           compiler.options.module?.rules.push({

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "vue-i18n-extract-plugin",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "main": "lib/index.js",
+  "types": "types/index.d.ts",
   "bin": {
     "extract-i18n": "lib/cli.js"
   },

package/types/babel-plugin-i18n.d.ts

@@ -0,0 +1,6 @@
+import { PluginObj, PluginPass } from '@babel/core';
+import { I18nOptions } from './options';
+
+declare const plugin: (api: any, options?: I18nOptions) => PluginObj<PluginPass>;
+
+export default plugin;

package/types/babel-plugin-import-i18n.d.ts

@@ -0,0 +1,6 @@
+import { PluginObj } from '@babel/core';
+import { I18nOptions } from './options';
+
+declare function babelPluginImportI18n(options?: I18nOptions): PluginObj;
+
+export = babelPluginImportI18n;

package/types/common.d.ts

@@ -0,0 +1,3 @@
+export interface I18nMap {
+    [key: string]: string;
+}

package/types/extract.d.ts

@@ -0,0 +1,28 @@
+import { Node } from '@babel/types';
+import { I18nOptions as Options } from './options';
+import { I18nMap } from './common';
+
+export interface WriteResult {
+  hasDiff: boolean;
+  data: I18nMap;
+}
+
+export function writeI18nMapToFile(
+  i18nMap: I18nMap,
+  options: Options,
+  checkDiffs?: boolean
+): Promise<WriteResult>;
+
+export function handleFinalI18nMap(
+  i18nMap: I18nMap,
+  options: Options,
+  checkDiffs?: boolean
+): Promise<void>;
+
+export function addI18nImportIfNeeded(ast: Node, options: Partial<Options>): Node
+export function addI18nImportIfNeeded(ast: Node, options: Partial<Options>, generateCode: false): Node
+export function addI18nImportIfNeeded(ast: Node, options: Partial<Options>, generateCode: true): string
+
+export function extractI18n(options: Options): Promise<void>;
+
+export let globalI18nMap: I18nMap; 

package/types/i18n.config.d.ts

@@ -0,0 +1,7 @@
+import { I18nOptions as Options } from './options';
+
+declare module 'extract-i18n.config' {
+    const config: Options;
+    export default config;
+  }
+  

package/types/import-i18n-transform.d.ts

@@ -0,0 +1,21 @@
+import { Node } from '@babel/types';
+
+export interface TransformResult {
+  ast: Node;
+  needTransform: boolean;
+}
+
+export function i18nImportAstTransform(
+  ast: Node,
+  importName: string,
+  importPath: string
+): TransformResult;
+
+export function i18nImportTransform(
+  code: string,
+  path: string,
+  importName: string,
+  importPath: string
+): Promise<string>;
+
+export function extractScriptContent(code: string, path: string): string; 

package/types/index.d.ts

@@ -0,0 +1,41 @@
+/// <reference path="./extract-i18n.config.d.ts" />
+
+export { default as babelPluginI18n } from "./babel-plugin-i18n";
+export { extractI18n, addI18nImportIfNeeded } from "./extract";
+export { I18nOptions as defaultOptions } from "./options";
+export {
+  autoTranslate,
+  translateChunks,
+  createTextSplitter
+} from "./translate";
+export * as translators from "./translators";
+export {
+  hashKey,
+  generateId,
+  parseArg,
+  checkAgainstRegexArray,
+  extractFunctionName,
+  relativeCWDPath,
+  getLangJsonPath,
+  shouldExtract,
+  trimEmptyLine,
+  padEmptyLine,
+  excludeDirectives,
+  EXCLUDED_CALL
+} from "./utils";
+export {
+  shouldTransform,
+  isTFunction,
+  createI18nVisitor,
+  createI18nPlugin
+} from "./visitors";
+export { default as vitePluginI18n } from "./vite-plugin-i18n";
+export { default as vitePluginImportI18n } from "./vite-plugin-import-i18n";
+export { default as WebpackPluginI18n } from "./webpack-plugin-i18n";
+export { default as vueI18nLoader } from "./vue-i18n-loader";
+export { default as babelPluginImportI18n } from "./babel-plugin-import-i18n";
+export {
+  i18nImportAstTransform,
+  i18nImportTransform,
+  extractScriptContent
+} from "./import-i18n-transform";

package/types/options.d.ts

@@ -0,0 +1,33 @@
+export type LangKey = "zh-cn" | 'zh-tw' | 'en' | 'ja' | 'ko' | 'ru' | string
+
+export interface I18nOptions {
+  translateKey: string
+  rewrite: boolean
+  extractFromText: boolean
+  autoImportI18n: boolean
+  autoTranslate: boolean
+  cleanTranslate: boolean
+  enabled: boolean
+  outputJsonFileInPlugin: boolean
+  outputJsonFileDebounceTimeInPlugin: number
+  translateInterval: number
+  excludedCall: string[]
+  includePath: string[] | string
+  excludedPath: string[] | string
+  allowedExtensions: string[]
+  fromLang: LangKey
+  translateLangKeys: LangKey[]
+  i18nPkgImportPath: string
+  outputPath: string
+  customGenLangFileName: (langKey: LangKey) => LangKey
+  customTranslatedText: (text: string, toLang: LangKey) => string,
+//   translator: new GoogleTranslator({
+//     // proxyOption: {
+//     //     port: 7890,
+//     //     host: '127.0.0.1',
+//     //     headers: {
+//     //         'User-Agent': 'Node'
+//     //     }
+//     // }
+//   })
+};

package/types/translate.d.ts

@@ -0,0 +1,18 @@
+import { I18nOptions, LangKey } from './options';
+import { I18nMap } from './common';
+
+export function createTextSplitter(values: string[], maxChunkSize: number): string[];
+
+export function cleanI18nMap(sourceObj: I18nMap, targetObj: I18nMap): I18nMap;
+
+export function autoTranslateFromFile(): Promise<void>;
+
+export function autoTranslate(i18nMap: I18nMap, option?: Partial<I18nOptions>): Promise<void>;
+
+export function cleanTranslate(option?: Partial<I18nOptions>): Promise<void>;
+
+export function translateChunks(
+  transLangObj: I18nMap,
+  toTranslateLang: LangKey,
+  option: Partial<I18nOptions>
+): Promise<string[]>; 

package/types/translators/index.d.ts

@@ -0,0 +1,186 @@
+import tunnel from 'tunnel';
+import { AxiosProxyConfig } from 'axios';
+
+interface TranslatorOption {
+    /** Translator版本，用于做后续的功能迭代 */
+    version?: number;
+    /**
+     * 实际的请求方法
+     * @param text 被翻译的文本
+     * @param fromKey 源语言
+     * @param toKey 目标语言
+     * @param separator 分隔符
+     * @returns 翻译后的文本
+     */
+    fetchMethod: (text: string, fromKey: string, toKey: string, separator: string) => Promise<string>;
+    name: string;
+    /** 单次最大翻译文本长度 */
+    maxChunkSize?: number;
+    /** 执行间隔（默认不开启） */
+    interval?: number;
+    /**
+     * 错误处理函数，主要是打印提示
+     * @param err 抛出的异常
+     * @param defaultErrorHandler 默认的错误处理函数
+     * @returns 如果在这里抛出异常会中断翻译
+     */
+    onError?: (err: unknown, defaultErrorHandler: (error: unknown) => void) => void;
+}
+declare class Translator {
+    option: Required<TranslatorOption>;
+    constructor(option: TranslatorOption);
+    private defaultErrorHandler;
+    private getResultOption;
+    protected getErrorMessage(error: unknown): string;
+    translate(text: string, fromKey: string, toKey: string, separator: string): Promise<string>;
+}
+
+interface GoogleTranslatorOption {
+    proxyOption?: tunnel.ProxyOptions;
+}
+/**
+ * 谷歌翻译器
+ *
+ * 基于@vitalets/google-translate-api，需要翻墙，不稳定，但是免费
+ *
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: translator: new GoogleTranslator({
+        proxyOption: {
+            // 如果你本地的代理在127.0.0.0:8899
+            host: '127.0.0.1',
+            port: 8899,
+            headers: {
+                'User-Agent': 'Node'
+            }
+        }
+    })
+})
+ * ```
+ */
+declare class GoogleTranslator extends Translator {
+    constructor(option: GoogleTranslatorOption);
+}
+
+interface YoudaoTranslatorOption {
+    appId: string;
+    appKey: string;
+    /** 网络代理配置 */
+    proxy?: AxiosProxyConfig;
+    /** 翻译api执行间隔，默认为1000 */
+    interval?: number;
+}
+/**
+ * 有道翻译器
+ *
+ * api文档：https://ai.youdao.com/DOCSIRMA/html/trans/api/wbfy/index.html
+ *
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: new YoudaoTranslator({
+        appId: '你申请的appId',
+        appKey: '你申请的appKey'
+    })
+})
+ * ```
+ */
+declare class YoudaoTranslator extends Translator {
+    /** 有道的语言类型映射不标准，需要手动控制 */
+    private readonly YOUDAO_TRANSLATE_KEY_CONVERT_MAP;
+    private truncate;
+    private getTranslateKey;
+    constructor(option: YoudaoTranslatorOption);
+}
+
+interface BaiduTranslatorOption {
+    appId: string;
+    appKey: string;
+    /** 网络代理配置 */
+    proxy?: AxiosProxyConfig;
+    /** 翻译api执行间隔，默认为1000 */
+    interval?: number;
+}
+/**
+ * 百度翻译器
+ *
+ * api文档：https://api.fanyi.baidu.com/product/113
+ *
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: new BaiduTranslator({
+        appId: '你申请的appId',
+        appKey: '你申请的appKey'
+    })
+})
+ * ```
+ */
+declare class BaiduTranslator extends Translator {
+    /** 百度的语言类型映射不标准，需要手动控制 */
+    protected readonly BAIDU_TRANSLATE_KEY_CONVERT_MAP: Record<string, string>;
+    protected getTranslateKey(key: string): string;
+    constructor(option: BaiduTranslatorOption);
+}
+
+/**
+ * 空翻译器，不翻译文本，用于配合某些特殊的操作
+ */
+declare class EmptyTranslator extends Translator {
+    constructor(option?: Partial<TranslatorOption>);
+}
+/** @deprecated 别名导出，兼容旧版本 */
+declare const ScanTranslator: typeof EmptyTranslator;
+
+interface VolcengineTranslatorOption {
+    apiKey: string;
+    /** 使用的ai模型，可选值请参阅火山引擎控制台的模型列表，如`doubao-1-5-pro-32k-250115`，并请确保使用前已在控制台开通了对应模型 */
+    model: string;
+    /** 对本项目的简短描述，在有描述的情况下大模型的翻译结果可能会更加准确 */
+    desc?: string;
+    /** 网络代理配置 */
+    proxy?: AxiosProxyConfig;
+    /** 翻译api执行间隔，默认为1000 */
+    interval?: number;
+}
+/**
+ * 火山引擎翻译器，内置豆包、deepseek等模型
+ *
+ * 火山引擎大模型介绍：https://www.volcengine.com/docs/82379/1099455
+ *
+ * api文档：https://www.volcengine.com/docs/82379/1298454
+ *
+ * 使用方式：
+ * ```ts
+ * vitePluginsAutoI18n({
+    ...
+    translator: new VolcengineTranslator({
+        apiKey: '你申请的apiKey',
+        model: '你要调用的模型，如：`doubao-1-5-pro-32k-250115`，请确保使用前已在控制台开通了对应模型'
+    })
+})
+ * ```
+ */
+declare class VolcengineTranslator extends Translator {
+    constructor(option: VolcengineTranslatorOption);
+}
+
+
+export {
+    BaiduTranslator,
+    BaiduTranslatorOption,
+    EmptyTranslator,
+    GoogleTranslator,
+    GoogleTranslatorOption,
+    ScanTranslator,
+    Translator,
+    TranslatorOption,
+    VolcengineTranslator,
+    VolcengineTranslatorOption,
+    YoudaoTranslator,
+    YoudaoTranslatorOption
+};

package/types/utils.d.ts

@@ -0,0 +1,21 @@
+import { NodePath } from "@babel/traverse";
+import { I18nOptions, LangKey } from './options';
+
+export function hashKey(str: string): string;
+export function generateId(text: string, length?: number): string;
+export function parseArg(arg: string): any;
+export function isEmptyObject(obj: Record<string, any>): boolean;
+export function checkAgainstRegexArray(value: string, regexArray?: (string | RegExp)[]): boolean;
+export function extractFunctionName(path: NodePath): string;
+export function relativeCWDPath(subPath: string): string;
+export function getLangJsonPath(langKey: LangKey, option: I18nOptions): string;
+export function readJsonWithDefault(pathStr: string, defaultValue?: Record<string, any>): Record<string, any>;
+export function resolveAliasPath(pathStr: string): string;
+export function resolveFilterPath(pathStr: string): string;
+export function fixFolderPath(pathStr: string | RegExp): string;
+export function sleep(ms: number): Promise<void>;
+export function shouldExtract(str: string, langKey: LangKey): boolean;
+export function trimEmptyLine(str: string): string;
+export function padEmptyLine(str: string): string;
+export const excludeDirectives: string[];
+export const EXCLUDED_CALL: string[];

package/types/visitors.d.ts

@@ -0,0 +1,9 @@
+import { Node } from '@babel/types';
+import { NodePath } from "@babel/traverse";
+import { I18nOptions } from "./options";
+import { I18nMap } from "./common";
+
+export declare function shouldTransform(path: NodePath): boolean;
+export declare function isTFunction(node: Node, option: I18nOptions): boolean;
+export declare function createI18nVisitor(option: I18nOptions, i18nMap?: I18nMap): Record<string, (path: NodePath) => void>;
+export declare function createI18nPlugin(option: I18nOptions, i18nMap?: I18nMap): () => { visitor: Record<string, (path: NodePath) => void> };

package/types/vite-plugin-i18n.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from 'vite';
+import { I18nOptions } from './options';
+
+export default function vitePluginI18n(option?: Partial<I18nOptions>): Plugin

package/types/vite-plugin-import-i18n.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from 'vite';
+import { I18nOptions } from './options';
+
+export default function vitePluginImportI18n(options?: Partial<I18nOptions>): Plugin; 

package/types/vue-i18n-loader.d.ts

@@ -0,0 +1,2 @@
+declare function vueI18nLoader(this: any, source: string): string;
+export = vueI18nLoader; 

package/types/webpack-import-i18n-loader.d.ts

@@ -0,0 +1,2 @@
+declare function webpackImportI18nLoader(this: any, source: string): string | Promise<string>;
+export = webpackImportI18nLoader;

package/types/webpack-plugin-i18n.d.ts

@@ -0,0 +1,9 @@
+import webpack from 'webpack'
+import { I18nOptions } from './options';
+
+export declare class WebpackPluginI18n {
+  options: I18nOptions;
+  timer: NodeJS.Timeout | null;
+  constructor(optionInfo?: Partial<I18nOptions>);
+  apply(compiler: webpack.Compiler): void;
+}