i18n-easy 1.0.0

package/lib/index.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  I18nEasy: () => import_i18n_easy.I18nEasy,
+  defineConfig: () => import_utils.defineConfig,
+  progressBus: () => import_progressBus.progressBus
+});
+module.exports = __toCommonJS(src_exports);
+var import_i18n_easy = require("./i18n_easy.js");
+var import_progressBus = require("./progressBus.js");
+var import_utils = require("./utils.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  I18nEasy,
+  defineConfig,
+  progressBus
+});

package/lib/key_map.js

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/key_map.ts
+var key_map_exports = {};
+__export(key_map_exports, {
+  default: () => KeyMap
+});
+module.exports = __toCommonJS(key_map_exports);
+var import_utils = require("./utils.js");
+var KeyMap = class _KeyMap {
+  // 字符映射表
+  charMap = /* @__PURE__ */ new Map();
+  // 生成的国际化文件key类型
+  keyType = "pinyin";
+  static instance;
+  constructor() {
+  }
+  // 获取单例实例
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new _KeyMap();
+    }
+    return this.instance;
+  }
+  // 获取字符映射表
+  get charList() {
+    return this.charMap;
+  }
+  // 将中文转换成拼音
+  generateKey(str) {
+    const trimStr = str.trim();
+    const key = (0, import_utils.generateKeyByKeyType)(trimStr, this.keyType);
+    this.setCharMap(key, trimStr);
+    return key;
+  }
+  // 清空字符映射表
+  clearCharMap() {
+    this.charMap.clear();
+  }
+  // 设置字符映射表
+  setCharMap(key, value) {
+    if (this.charMap.has(key)) {
+      return;
+    }
+    this.charMap.set(key, value);
+  }
+  //  判断字符映射表是否为空
+  isEmpty() {
+    return this.charMap.size === 0;
+  }
+  // 设置映射表类型
+  setKeyType(type) {
+    this.keyType = type;
+  }
+};

package/lib/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/lib/patch.d.ts

@@ -0,0 +1,5 @@
+declare module 'espree'
+
+declare module 'eslint-scope' {
+  export interface ScopeManager {}
+}

package/lib/progressBus.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/progressBus.ts
+var progressBus_exports = {};
+__export(progressBus_exports, {
+  log: () => log,
+  progressBus: () => progressBus
+});
+module.exports = __toCommonJS(progressBus_exports);
+var import_events = require("events");
+var colors = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  blue: "\x1B[34m"
+};
+var statusColorMap = {
+  fail: colors.red,
+  info: colors.blue,
+  success: colors.green
+};
+var progressBus = new import_events.EventEmitter();
+function colorLog(msg, status) {
+  console.log(`${statusColorMap[status]}${msg}${colors.reset}`);
+}
+function log(msg, status) {
+  colorLog(msg, status);
+  progressBus.emit("log", msg, status);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  log,
+  progressBus
+});

package/lib/translate.js

@@ -0,0 +1,127 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/translate.ts
+var translate_exports = {};
+__export(translate_exports, {
+  default: () => Translate
+});
+module.exports = __toCommonJS(translate_exports);
+var import_uuid = require("uuid");
+var import_utils = require("./utils.js");
+var Translate = class _Translate {
+  // 微软翻译API
+  endpoint = "https://api.cognitive.microsofttranslator.com/translate";
+  // 微软翻译API密钥
+  apiKey;
+  // 单例实例
+  static instance;
+  constructor() {
+  }
+  // 获取单例实例
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new _Translate();
+    }
+    return this.instance;
+  }
+  /**
+   * 构建微软翻译API请求配置
+   * @param originalTextArr 原始文本数组，每个元素为{ text: string }
+   * @param lang 目标语言数组
+   * @returns 
+   */
+  buildRequestConfig(originalTextArr, lang) {
+    const url = new URL(this.endpoint);
+    url.searchParams.append("api-version", "3.0");
+    url.searchParams.append("from", "zh");
+    lang.forEach((toLang) => url.searchParams.append("to", toLang));
+    return {
+      url,
+      method: "POST",
+      headers: {
+        "Ocp-Apim-Subscription-Key": this.apiKey,
+        "Ocp-Apim-Subscription-Region": "global",
+        "Content-type": "application/json",
+        "X-ClientTraceId": (0, import_uuid.v4)().toString()
+      },
+      body: JSON.stringify(originalTextArr)
+    };
+  }
+  /**
+   * 处理微软翻译API响应数据
+   * @param responseData 翻译API响应数据，每个元素为{ translations: { text: string }[] }
+   * @param originalTextArr 原始文本数组，每个元素为[ key: string, text: string ]
+   * @param lang 目标语言数组
+   * @returns 翻译结果，格式为{ language: { key: text } }
+   */
+  processResponse(responseData, originalTextArr, lang) {
+    const translationResult = {};
+    responseData.forEach((arrItem, i) => {
+      const key = originalTextArr[i][0];
+      arrItem.translations.forEach((item, j) => {
+        const language = lang[j];
+        translationResult[language] = translationResult[language] || {};
+        translationResult[language][key] = item.text;
+      });
+    });
+    return translationResult;
+  }
+  /**
+   * 翻译中文为其他指定语言
+   * @param originalTextArr 原始文本数组，每个元素为[ key: string, text: string ]
+   * @param lang 目标语言数组
+   * @returns 翻译结果，格式为{ language: { key: text } }
+   */
+  async translate(originalTextArr, lang) {
+    if (!this.apiKey) {
+      throw new Error("配置文件缺失配置项：微软翻译apiKey不能为空");
+    }
+    if (!lang.length) {
+      throw new Error("配置文件缺失配置项：目标语言lang不能为空");
+    }
+    if (!originalTextArr.length) {
+      return {};
+    }
+    const textArr = originalTextArr.map(([_, text]) => {
+      if (!text.includes("{") && !text.includes("}")) {
+        return { text };
+      }
+      const str = text.replace(/({\s*arg[0-9]\s*})/g, (str2) => (0, import_utils.customTranslation)(str2, str2));
+      return { text: str };
+    });
+    const { url, ...config } = this.buildRequestConfig(textArr, lang);
+    try {
+      const response = await fetch(url, config);
+      if (!response.ok) {
+        throw new Error(`翻译API请求失败，响应状态码：${response.status}`);
+      }
+      const data = await response.json();
+      return this.processResponse(data, originalTextArr, lang);
+    } catch (error) {
+      throw new Error(error instanceof Error ? error.message : String(error));
+    }
+  }
+  /**
+   * 设置微软翻译API密钥
+   * @param apiKey 微软翻译API密钥
+   */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+};

package/lib/type.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/type.ts
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);

package/lib/utils.js

@@ -0,0 +1,142 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  customTranslation: () => customTranslation,
+  defineConfig: () => defineConfig,
+  generateKeyByKeyType: () => generateKeyByKeyType,
+  hasChineseChar: () => hasChineseChar,
+  isSupportFileType: () => isSupportFileType,
+  isVueScriptSrcImport: () => isVueScriptSrcImport,
+  searchFileContent: () => searchFileContent
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_path = __toESM(require("node:path"));
+var import_node_fs = require("node:fs");
+var import_glob = require("glob");
+var import_compiler_sfc = require("@vue/compiler-sfc");
+var import_pinyin_pro = require("pinyin-pro");
+var import_modern = __toESM(require("@pinyin-pro/data/modern"));
+var import_cosmiconfig = require("cosmiconfig");
+(0, import_pinyin_pro.addDict)(import_modern.default);
+function hasChineseChar(str) {
+  if (!str) {
+    return false;
+  }
+  return /[\u4e00-\u9fa5]/.test(str);
+}
+function generateHash(char) {
+  const hash = (0, import_node_crypto.createHash)("md5");
+  hash.update(char);
+  return hash.digest("hex").slice();
+}
+function generatePinYin(char, toneType) {
+  const filtered = char.replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
+  return (0, import_pinyin_pro.pinyin)(filtered, {
+    separator: "_",
+    // 分隔符
+    toneType,
+    // 声调
+    nonZh: "consecutive",
+    // 非汉字在结果中紧凑输出
+    nonZhScope: /[a-zA-Z0-9]/
+    // 指定nonZh范围的正则
+  });
+}
+function generateKeyByKeyType(char, keyType) {
+  if (keyType === "hash") {
+    return generateHash(char);
+  } else if (keyType === "pinyinWithNumber") {
+    return generatePinYin(char, "num");
+  } else {
+    return generatePinYin(char, "none");
+  }
+}
+async function isVueScriptSrcImport(filePath, fileType) {
+  if (!["js", "ts"].includes(fileType)) {
+    return false;
+  }
+  const vueFiles = await (0, import_glob.glob)("*.vue", { cwd: import_node_path.default.dirname(filePath), absolute: true, nodir: true });
+  for (const file of vueFiles) {
+    const code = await import_node_fs.promises.readFile(file, "utf8");
+    const { descriptor } = (0, import_compiler_sfc.parse)(code);
+    const { script } = descriptor;
+    if ((script == null ? void 0 : script.src) && import_node_path.default.resolve(import_node_path.default.dirname(file), script.src) === filePath) {
+      return true;
+    }
+  }
+  return false;
+}
+function isSupportFileType(fileType, framework) {
+  const SUPPORT_FILE_TYPE_MAP = {
+    vue: /* @__PURE__ */ new Set(["vue", "js", "jsx", "ts", "tsx"]),
+    react: /* @__PURE__ */ new Set(["js", "jsx", "ts", "tsx"])
+  };
+  return SUPPORT_FILE_TYPE_MAP[framework].has(fileType);
+}
+async function searchFileContent(dirPath, searchPlaces) {
+  const explorer = (0, import_cosmiconfig.cosmiconfig)("", {
+    searchStrategy: "none",
+    searchPlaces,
+    loaders: {
+      ".json": import_cosmiconfig.defaultLoaders[".json"],
+      // 保持默认 JSON 加载器
+      ".js": import_cosmiconfig.defaultLoaders[".js"],
+      // 保持默认 JS 加载器
+      ".mjs": import_cosmiconfig.defaultLoaders[".mjs"],
+      // 保持默认 MJS 加载器
+      ".cjs": import_cosmiconfig.defaultLoaders[".cjs"],
+      // 保持默认 CJS 加载器
+      ".ts": import_cosmiconfig.defaultLoaders[".ts"],
+      // 保持默认 TS 加载器'
+      noExt: import_cosmiconfig.defaultLoaders[".json"]
+      // 无扩展名文件作为 JSON 处理
+    }
+  });
+  const result = await explorer.search(dirPath);
+  return result ? result.config : null;
+}
+function defineConfig(config) {
+  return config;
+}
+function customTranslation(source, translation) {
+  return `<mstrans:dictionary translation=${translation}>${source}</mstrans:dictionary>`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  customTranslation,
+  defineConfig,
+  generateKeyByKeyType,
+  hasChineseChar,
+  isSupportFileType,
+  isVueScriptSrcImport,
+  searchFileContent
+});

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "i18n-easy",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "一个一键国际化工具，用于将代码中的中文转换成国际化写法，并将翻译内容写入指定的语言文件中。提高开发效率，简化国际化流程。",
+  "keywords": [
+    "i18n",
+    "国际化",
+    "中文国际化",
+    "翻译",
+    "国际化工具",
+    "代码转换",
+    "翻译管理",
+    "国际化文件生成"
+  ],
+  "types": "./types/index.d.ts",
+  "exports": {
+    "import": {
+      "types": "./types/index.d.ts",
+      "default": "./esm/index.js"
+    },
+    "require": {
+      "types": "./types/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "main": "./lib/index.js",
+  "bin": {
+    "i18n-easy": "./lib/cli.js"
+  },
+  "files": [
+    "lib",
+    "esm",
+    "types",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "father build",
+    "build:types": "tsc --project tsconfig.types.json",
+    "build:all": "pnpm build && pnpm build:types",
+    "postbuild": "tsx post-build.ts"
+  },
+  "devDependencies": {
+    "@types/estree": "^1.0.6",
+    "@types/node": "^22.13.9",
+    "@typescript-eslint/utils": "^8.46.0",
+    "jiti": "^2.4.2",
+    "tsx": "^4.19.3",
+    "typescript": "~5.7.2"
+  },
+  "dependencies": {
+    "@pinyin-pro/data": "^1.2.0",
+    "@typescript-eslint/parser": "^8.32.1",
+    "@vue/compiler-sfc": "^3.5.22",
+    "cosmiconfig": "^9.0.0",
+    "eslint": "^9.27.0",
+    "espree": "^10.3.0",
+    "father": "4.2.0",
+    "glob": "^11.0.3",
+    "json5": "^2.2.3",
+    "pinyin-pro": "^3.26.0",
+    "simple-git": "^3.28.0",
+    "uuid": "^11.1.0",
+    "vue-eslint-parser": "^10.1.3"
+  }
+}

package/types/assets/const.d.ts

@@ -0,0 +1,2 @@
+export declare const configFileNames: string[];
+export declare const checkReg: RegExp;

package/types/ast_transformer.d.ts

@@ -0,0 +1,19 @@
+import { Framework, SupportFileMap, I18nInfoType, ReactI18nInfoType, TextNode, ReactCollectItemType } from './type.js';
+import { type Rule } from 'eslint';
+interface Props<T extends Framework> {
+    fileContent: string;
+    fileName: string;
+    fileType: SupportFileMap[T];
+    type: T;
+    i18nInfo: T extends 'vue' ? I18nInfoType : ReactI18nInfoType;
+    customIgnore?: (node: T extends 'vue' ? TextNode : ReactCollectItemType['textNode'], context: Rule.RuleContext) => boolean;
+}
+export declare class AstTransformer {
+    private linter;
+    constructor();
+    convertFileContent<T extends Framework>(props: Props<T>): {
+        newFileContent: string;
+        fixed: boolean;
+    };
+}
+export {};

package/types/eslint/react/i18n_easy_plugin.d.ts

@@ -0,0 +1,3 @@
+import type { ESLint } from 'eslint';
+declare const ReactPlugin: ESLint.Plugin;
+export default ReactPlugin;

package/types/eslint/react/i18n_utils.d.ts

@@ -0,0 +1,61 @@
+import type { Rule } from 'eslint';
+import * as ESTree from 'estree';
+import { ReactCodeType, ReactCollectItemType, ReactInjectCodeType } from '../../type.js';
+/**
+ * @description 创建忽略注释检查器
+ * @param context - 规则上下文
+ * @returns 忽略注释检查函数
+ */
+export declare function createI18nIgnoreChecker(context: Rule.RuleContext): (node: ReactCollectItemType["textNode"]) => boolean;
+/**
+ * @description 判断能否注入
+ * @param context - 规则上下文
+ * @param node - 节点 （Program、组件、hooks节点）
+ * @param codeType - 代码类型
+ * @returns 是否能注入
+ */
+export declare function canInject(context: Rule.RuleContext, node: ReactInjectCodeType, codeType: ReactCodeType): boolean;
+/**
+ * @description 获取最后一个 import 或第一个非 import 节点
+ ** 1、不存在节点返回null
+ ** 2、存在import节点，返回最后一个import节点
+ ** 3、不存在import节点，返回第一个非import节点
+ * @param context - 规则上下文
+ * @returns 节点信息
+ */
+export declare function getLastImportOrFirstNotImportNode(context: Rule.RuleContext): {
+    node: ESTree.Node;
+    type: string;
+} | null;
+/**
+ * @description 获取注入节点
+ * @param context - 规则上下文
+ * @param node - BlockStatement节点
+ * @returns 第一个子节点（包含注释节点）
+ */
+export declare function getInjectNode(context: Rule.RuleContext, node: ESTree.BlockStatement): ESTree.Comment | ESTree.Statement;
+/**
+ * @description 判断能否收集操作节点
+ **  排除：
+ **   1、显示使用@i18n-ignore注释的节点
+ **   2、未使用中文的节点
+ * @param node - 节点 （TemplateLiteral、Literal、JSXText节点）
+ * @param isIgnored - 判断是否被忽略的函数
+ * @returns 是否能收集操作节点
+ */
+export declare function canCollectOperateNodes(node: ReactCollectItemType['textNode'], isIgnored: (n: ReactCollectItemType['textNode']) => boolean): boolean;
+/**
+ * @description 获取节点前的空格
+ * @param context - 规则上下文
+ * @param node - 节点
+ * @returns 节点前的空格
+ */
+export declare function getLeadingSpaces(context: Rule.RuleContext, node: ESTree.Node | ESTree.Comment): string;
+/**
+ * @description 获取国际化调用方法
+ * @param callMethodName - 国际化调用方法
+ * @param key - 国际化键值
+ * @param value - 国际化参数
+ * @returns 国际化调用方法
+ */
+export declare function getI18nCallMethod(callMethodName: string, key: string, value?: string): string;

package/types/eslint/react/report_and_fix.d.ts

@@ -0,0 +1,67 @@
+import type { Rule } from 'eslint';
+import * as ESTree from 'estree';
+import { ReactCollectItemType, ReactCollectListType, ReactCodeType } from '../../type.js';
+type FixFunType = ((fixer: Rule.RuleFixer) => Rule.Fix | Iterable<Rule.Fix> | null) | null;
+/**
+ * @description 生成替换中文为国际化写法修复函数
+ * @param context - 规则上下文
+ * @param node - 节点
+ * @param codeType - 代码类型
+ * @returns 修复函数
+ * @example 原始代码：<span>张三</span> 修复后代码：<span>{ formatMessage({ id: 'zhang_san'}) }</span>
+ */
+export declare function generateReplaceKeyFixFun(context: Rule.RuleContext, node: ReactCollectItemType['textNode'], codeType: ReactCodeType): FixFunType;
+/**
+ * @description 生成注入import语句的修复函数
+ * @param context - 规则上下文
+ * @param codeType - 代码类型
+ * @returns 修复函数
+ * @example
+ *  原始代码：
+ *      const a = 1
+ *  修复后代码：
+ *      import i18n from '@/i18n/i18n.js' // 注入导入语句
+ *      const a = 1
+ */
+export declare function generateInjectImportFixFun(context: Rule.RuleContext, codeType: ReactCodeType): FixFunType;
+/**
+ * @description 生成注入hooks调用语句的修复函数
+ * @param context - 规则上下文
+ * @param node - 节点
+ * @returns 修复函数
+ * @example
+ *  原始代码：
+ *    function Button() {
+ *      return <span>按钮</span>
+ *    }
+ *  修复后代码：
+ *    function Button() {
+ *      const { formatMessage } = useI18n() // 注入hooks调用语句
+ *      return <span>按钮</span>
+ *    }
+ */
+export declare function generateInjectHooksCallFixFun(context: Rule.RuleContext, node: ESTree.FunctionDeclaration | ESTree.VariableDeclarator): FixFunType;
+/**
+ * @description 生成注入代码到顶部的修复函数
+ * @param context - 规则上下文
+ * @param codeType - 代码类型
+ * @returns 修复函数
+ * @example
+ *  原始代码：
+ *    function Button() {
+ *      return <span>{formatMessage('button')}</span>
+ *    }
+ *  修复后代码：
+ *    const { formatMessage } = getIntl();  // 注入代码到顶部
+ *    function Button() {
+ *      return <span>{formatMessage('button')}</span>
+ *    }
+ */
+export declare function generateInjectCodeToTopLevelFixFun(context: Rule.RuleContext, codeType: ReactCodeType): FixFunType;
+/**
+ * @description 批量执行修复函数 根据收集到节点生成修复函数并执行
+ * @param context - 规则上下文
+ * @param state - 收集到的节点列表
+ */
+export declare function batchFixAll(context: Rule.RuleContext, state: ReactCollectListType): void;
+export {};