i18n-easy 1.0.0

package/esm/eslint/react/i18n_easy_plugin.js

@@ -0,0 +1,111 @@
+// src/eslint/react/i18n_easy_plugin.ts
+import { batchFixAll } from "./report_and_fix.js";
+import { createI18nIgnoreChecker, canCollectOperateNodes } from "./i18n_utils.js";
+var ReactPlugin = {
+  rules: {
+    "i18n-transform": {
+      meta: {
+        type: "problem",
+        messages: { hasChinese: "当前文件存在中文字符‘{{ char }}’，可进行国际化替换" },
+        fixable: "code"
+      },
+      create(context) {
+        const customIgnore = context.settings.customIgnore;
+        let isIgnored;
+        const state = {
+          inComponent: [],
+          // 组件内中文
+          outComponent: []
+          // 组件外中文
+        };
+        let inComp = false;
+        let compNode = null;
+        const enterComp = () => inComp = true;
+        const exitComp = () => inComp = false;
+        const collectNodes = (textNode, programNode) => {
+          if (customIgnore == null ? void 0 : customIgnore(textNode, context)) return;
+          if (!canCollectOperateNodes(textNode, isIgnored)) return;
+          const payload = { textNode, componentNode: inComp ? compNode : null, programNode: inComp ? null : programNode, inComp };
+          if (inComp) {
+            state.inComponent.push(payload);
+            return;
+          }
+          state.outComponent.push(payload);
+        };
+        const collectScriptOperateNodesVisitor = {
+          // 字面量节点
+          Literal(node) {
+            collectNodes(node, context.sourceCode.ast);
+          },
+          // 模版字符串节点
+          TemplateLiteral(node) {
+            collectNodes(node, context.sourceCode.ast);
+          },
+          // JSX文本节点
+          JSXText(node) {
+            collectNodes(node, context.sourceCode.ast);
+          }
+        };
+        const injectConfigCodeVisitor = {
+          /**
+           *  进入时 记录@i18n-ignore注释所在行号
+           */
+          Program: function() {
+            isIgnored = createI18nIgnoreChecker(context);
+          },
+          /**
+           * 退出时
+           *    1、替换中文为国际化写法
+           *    2、注入配置代码
+           */
+          "Program:exit": function() {
+            batchFixAll(context, state);
+          },
+          // 组件 function Component(){}
+          "FunctionDeclaration[id.name=/^[A-Z]/]": function(node) {
+            compNode = node;
+            enterComp();
+          },
+          "FunctionDeclaration[id.name=/^[A-Z]/]:exit": exitComp,
+          // 组件 const Component = () => {}
+          "VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression": function(node) {
+            compNode = node.parent;
+            enterComp();
+          },
+          "VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression:exit": exitComp,
+          // 组件 const Component = function(){}
+          "VariableDeclarator[id.name=/^[A-Z]/] > FunctionExpression": function(node) {
+            compNode = node.parent;
+            enterComp();
+          },
+          "VariableDeclarator[id.name=/^[A-Z]/] > FunctionExpression:exit": exitComp,
+          // 自定义hooks(同理)
+          "FunctionDeclaration[id.name=/^use[A-Z]/]": function(node) {
+            compNode = node;
+            enterComp();
+          },
+          "FunctionDeclaration[id.name=/^use[A-Z]/]:exit": exitComp,
+          "VariableDeclarator[id.name=/^use[A-Z]/] > ArrowFunctionExpression": function(node) {
+            compNode = node.parent;
+            enterComp();
+          },
+          "VariableDeclarator[id.name=/^use[A-Z]/] > ArrowFunctionExpression:exit": exitComp,
+          "VariableDeclarator[id.name=/^use[A-Z]/] > FunctionExpression": function(node) {
+            compNode = node.parent;
+            enterComp();
+          },
+          "VariableDeclarator[id.name=/^use[A-Z]/] > FunctionExpression:exit": exitComp
+        };
+        const replaceOperateNodesAndInjectVisitor = {
+          ...collectScriptOperateNodesVisitor,
+          ...injectConfigCodeVisitor
+        };
+        return replaceOperateNodesAndInjectVisitor;
+      }
+    }
+  }
+};
+var i18n_easy_plugin_default = ReactPlugin;
+export {
+  i18n_easy_plugin_default as default
+};

package/esm/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.Statement | ESTree.Comment;
+/**
+ * @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/esm/eslint/react/i18n_utils.js

@@ -0,0 +1,115 @@
+// src/eslint/react/i18n_utils.ts
+import { hasChineseChar } from "../../utils.js";
+function createI18nIgnoreChecker(context) {
+  const ignoreLines = [];
+  const jsComments = context.sourceCode.getAllComments();
+  for (const comment of jsComments) {
+    if (["HTMLComment", "Line", "Block"].includes(comment.type) && comment.value.trim().includes("@i18n-ignore")) {
+      ignoreLines.push([comment.loc.start.line, comment.loc.end.line]);
+    }
+  }
+  return function isIgnored(node) {
+    const nodeStartLine = node.loc.start.line;
+    const nodeEndLine = node.loc.end.line;
+    if (nodeStartLine !== nodeEndLine) return false;
+    return ignoreLines.some(([_start, end]) => end === nodeEndLine - 1);
+  };
+}
+function getScope(context, node) {
+  if (node.type === "Program") {
+    const programScope = context.sourceCode.getScope(node);
+    return programScope.type == "global" ? programScope.childScopes[0] : programScope;
+  }
+  if (["FunctionDeclaration", "VariableDeclarator"].includes(node.type)) {
+    return context.sourceCode.getScope(node);
+  }
+  return null;
+}
+function canInject(context, node, codeType) {
+  if (!node) return false;
+  const { callMethodName } = context.settings.i18nInfo[codeType] || {};
+  if (!callMethodName) return false;
+  const scope = getScope(context, node);
+  if (!scope) return false;
+  return scope.variables.some((ref) => ref.name === callMethodName) === false;
+}
+function getLastImportOrFirstNotImportNode(context) {
+  const src = context.sourceCode;
+  const body = src.ast.body;
+  let lastImport = body.filter((n) => n.type === "ImportDeclaration").pop();
+  if (lastImport) {
+    return {
+      node: lastImport,
+      type: "lastImport"
+    };
+  }
+  let firstNonImport = null;
+  const allNodes = [...body];
+  const commentsAsNodes = src.getAllComments();
+  const sorted = [...allNodes, ...commentsAsNodes].sort((a, b) => {
+    if (a.range && b.range) {
+      return a.range[0] - b.range[0];
+    }
+    return 0;
+  });
+  firstNonImport = sorted.find((n) => n.type !== "ImportDeclaration");
+  if (firstNonImport) {
+    return {
+      node: firstNonImport,
+      type: "firstNonImport"
+    };
+  }
+  return null;
+}
+function getInjectNode(context, node) {
+  const commentNodes = context.sourceCode.getAllComments();
+  const comments = commentNodes.filter((item) => {
+    if (item.range && node.range) {
+      return item.range[0] >= node.range[0] && item.range[1] <= node.range[1];
+    }
+    return false;
+  });
+  const sorted = [...comments, ...node.body].sort((a, b) => {
+    if (a.range && b.range) {
+      return a.range[0] - b.range[0];
+    }
+    return 0;
+  });
+  return sorted[0];
+}
+function canCollectOperateNodes(node, isIgnored) {
+  if (isIgnored(node)) return false;
+  switch (node.type) {
+    case "TemplateLiteral":
+      if (!node.quasis.some((q) => hasChineseChar(q.value.cooked))) return false;
+      return true;
+    case "Literal":
+      if (!hasChineseChar(node.value)) return false;
+      return true;
+    case "JSXText":
+      if (!hasChineseChar(node.value)) return false;
+      return true;
+    default:
+      return false;
+  }
+}
+function getLeadingSpaces(context, node) {
+  if (!node.loc) return "";
+  const line = context.sourceCode.lines[node.loc.start.line - 1];
+  return line.slice(0, node.loc.start.column);
+}
+function getI18nCallMethod(callMethodName, key, value) {
+  if (value) {
+    return `${callMethodName}('${key}', { ${value} })`;
+  }
+  return `${callMethodName}('${key}')`;
+}
+export {
+  canCollectOperateNodes,
+  canInject,
+  createI18nIgnoreChecker,
+  getI18nCallMethod,
+  getInjectNode,
+  getLastImportOrFirstNotImportNode,
+  getLeadingSpaces
+};

package/esm/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';
+declare 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 {};

package/esm/eslint/react/report_and_fix.js

@@ -0,0 +1,118 @@
+// src/eslint/react/report_and_fix.ts
+import { canInject, getI18nCallMethod, getInjectNode, getLastImportOrFirstNotImportNode, getLeadingSpaces } from "./i18n_utils.js";
+import KeyMap from "../../key_map.js";
+var keyMapper = KeyMap.getInstance();
+function generateReplaceKeyFixFun(context, node, codeType) {
+  const { callMethodName } = context.settings.i18nInfo[codeType] || {};
+  if (!callMethodName) return null;
+  switch (node.type) {
+    case "TemplateLiteral":
+      return (fixer) => {
+        const str = node.quasis.map((q, index) => q.tail ? q.value.cooked : `${q.value.cooked}{arg${index + 1}}`).join("");
+        const key = keyMapper.generateKey(str);
+        const expressionsArr = node.expressions;
+        if (expressionsArr.length) {
+          const paramsStr = expressionsArr.map((i, index) => `arg${index + 1}: ${context.sourceCode.getText(i)}`).join(", ");
+          const value = context.sourceCode.getText(node);
+          const afterReplaceKey = value.replace(value.trim(), key);
+          const replaceStr2 = `${getI18nCallMethod(callMethodName, afterReplaceKey, paramsStr)}`;
+          return fixer.replaceTextRange(node.range, replaceStr2);
+        }
+        const replaceStr = `${getI18nCallMethod(callMethodName, key)}`;
+        return fixer.replaceTextRange(node.range, replaceStr);
+      };
+    case "Literal":
+      return (fixer) => {
+        const value = node.value;
+        const key = keyMapper.generateKey(value);
+        const str = node.parent.type === "JSXAttribute" ? `{ ${getI18nCallMethod(callMethodName, key)} }` : `${getI18nCallMethod(callMethodName, key)}`;
+        const replaceStr = value.replace(value.trim(), str);
+        return fixer.replaceTextRange(node.range, replaceStr);
+      };
+    case "JSXText":
+      return (fixer) => {
+        const value = node.value;
+        const key = keyMapper.generateKey(value);
+        return fixer.replaceTextRange(node.range, `{ ${getI18nCallMethod(callMethodName, key)} }`);
+      };
+    default:
+      return () => null;
+  }
+}
+function generateInjectImportFixFun(context, codeType) {
+  const { injectImport } = context.settings.i18nInfo[codeType] || {};
+  if (!injectImport) return null;
+  return (fixer) => {
+    const res = getLastImportOrFirstNotImportNode(context);
+    if (!res) return null;
+    const { node: injectNode, type } = res;
+    const indent = getLeadingSpaces(context, injectNode);
+    if (type === "firstNonImport") {
+      return fixer.insertTextBeforeRange(injectNode.range, `${injectImport}
+${indent}`);
+    }
+    return fixer.insertTextAfterRange(injectNode.range, `
+${indent}${injectImport}`);
+  };
+}
+function generateInjectHooksCallFixFun(context, node) {
+  const { injectHooksCall } = context.settings.i18nInfo["jsx"] || {};
+  if (!injectHooksCall) return null;
+  return function(fixer) {
+    const blockStatementNode = node.type === "FunctionDeclaration" ? node.body : node.init.body;
+    const injectNode = getInjectNode(context, blockStatementNode);
+    const indent = getLeadingSpaces(context, injectNode);
+    return fixer.insertTextBeforeRange(injectNode.range, `${injectHooksCall}
+${indent}`);
+  };
+}
+function generateInjectCodeToTopLevelFixFun(context, codeType) {
+  const { injectCodeToTopLevel } = context.settings.i18nInfo[codeType] || {};
+  if (!injectCodeToTopLevel) return null;
+  return (fixer) => {
+    const res = getLastImportOrFirstNotImportNode(context);
+    if (!res) return null;
+    const { node: injectNode, type } = res;
+    const indent = getLeadingSpaces(context, injectNode);
+    if (type === "firstNonImport") {
+      return fixer.insertTextBeforeRange(injectNode.range, `${injectCodeToTopLevel}
+${indent}`);
+    }
+    return fixer.insertTextAfterRange(injectNode.range, `
+${indent}${injectCodeToTopLevel}`);
+  };
+}
+function batchFixAll(context, state) {
+  if (!state.inComponent.length && !state.outComponent.length) return;
+  const injectHasInjectCompOrHooksMap = /* @__PURE__ */ new Map();
+  const fixArr = [...state.inComponent, ...state.outComponent].map((item) => generateReplaceKeyFixFun(context, item.textNode, item.inComp ? "jsx" : "js"));
+  if (state.outComponent.length && canInject(context, context.sourceCode.ast, "js")) {
+    fixArr.unshift(generateInjectImportFixFun(context, "js"));
+    fixArr.push(generateInjectCodeToTopLevelFixFun(context, "js"));
+  }
+  for (const { componentNode } of state.inComponent) {
+    const name = componentNode.id.name;
+    if (!injectHasInjectCompOrHooksMap.has(name) && canInject(context, componentNode, "jsx")) {
+      fixArr.push(generateInjectHooksCallFixFun(context, componentNode));
+      injectHasInjectCompOrHooksMap.set(name, componentNode);
+    }
+  }
+  if (injectHasInjectCompOrHooksMap.size) {
+    fixArr.unshift(generateInjectImportFixFun(context, "jsx"));
+    fixArr.push(generateInjectCodeToTopLevelFixFun(context, "jsx"));
+  }
+  const fixes = fixArr.filter((f) => f !== null);
+  if (!fixes.length) return;
+  context.report({
+    loc: context.sourceCode.ast.loc,
+    message: "存在中文字符，可以进行国际化替换",
+    fix: (fixer) => fixes.map((f) => f(fixer)).filter(Boolean)
+  });
+}
+export {
+  batchFixAll,
+  generateInjectCodeToTopLevelFixFun,
+  generateInjectHooksCallFixFun,
+  generateInjectImportFixFun,
+  generateReplaceKeyFixFun
+};

package/esm/eslint/vue/i18n_easy_plugin.d.ts

@@ -0,0 +1,5 @@
+import type { ESLint } from 'eslint';
+import { BaseCodeType, TextNode } from '../../type.js';
+export declare type CollectNodes = (textNode: TextNode, codeType: Extract<BaseCodeType, 'js' | 'jsx' | 'script' | 'template'>) => void;
+declare const VuePlugin: ESLint.Plugin;
+export default VuePlugin;

package/esm/eslint/vue/i18n_easy_plugin.js

@@ -0,0 +1,141 @@
+// src/eslint/vue/i18n_easy_plugin.ts
+import { batchFixAll } from "./report_and_fix.js";
+import { createI18nIgnoreChecker, canCollectOperateNodes, isScriptSetup } from "./i18n_utils.js";
+var DiFF_FILE_JS_CODE_MAP = {
+  vue: "script",
+  js: "js",
+  jsx: "jsx",
+  ts: "js",
+  tsx: "jsx"
+};
+var VuePlugin = {
+  rules: {
+    "i18n-transform": {
+      meta: {
+        type: "problem",
+        messages: { hasChinese: "当前文件存在中文字符，可进行国际化替换" },
+        fixable: "code"
+      },
+      create(context) {
+        const fileType = context.settings.fileType;
+        const customIgnore = context.settings.customIgnore;
+        const state = {
+          templateTextNodeList: [],
+          scriptTextNodeList: [],
+          jsTextNodeList: [],
+          jsxTextNodeList: []
+        };
+        let inSetup = false;
+        let setupNode = null;
+        let isIgnored;
+        const enterSetup = (node) => {
+          setupNode = node;
+          inSetup = true;
+        };
+        const leaveSetup = () => {
+          setupNode = null;
+          inSetup = false;
+        };
+        const collectNodes = (textNode, codeType) => {
+          if (customIgnore == null ? void 0 : customIgnore(textNode, context)) {
+            return;
+          }
+          if (!canCollectOperateNodes(textNode, isIgnored)) return;
+          switch (codeType) {
+            case "template":
+              state.templateTextNodeList.push({ textNode, setUpNode: null, inSetup: false, codeType });
+              break;
+            case "script":
+              state.scriptTextNodeList.push({ textNode, setUpNode: inSetup ? setupNode : null, inSetup, codeType });
+              break;
+            case "js":
+              state.jsTextNodeList.push({ textNode, setUpNode: null, inSetup: false, codeType });
+              break;
+            case "jsx":
+              state.jsxTextNodeList.push({ textNode, setUpNode: inSetup ? setupNode : null, inSetup, codeType });
+              break;
+          }
+        };
+        const collectTemplateChineseTextNodeVisitor = {
+          // 文本节点
+          VText(node) {
+            collectNodes(node, "template");
+          },
+          // 属性节点
+          VAttribute(node) {
+            collectNodes(node, "template");
+          },
+          // 模板字符串节点
+          TemplateLiteral(node) {
+            collectNodes(node, "template");
+          },
+          // 字面量节点
+          Literal(node) {
+            collectNodes(node, "template");
+          }
+        };
+        const collectScriptChineseTextNodeVisitor = {
+          // 字面量节点
+          Literal(node) {
+            collectNodes(node, DiFF_FILE_JS_CODE_MAP[fileType]);
+          },
+          // 模版字符串节点
+          TemplateLiteral(node) {
+            collectNodes(node, DiFF_FILE_JS_CODE_MAP[fileType]);
+          },
+          // JSX文本节点
+          JSXText(node) {
+            collectNodes(node, DiFF_FILE_JS_CODE_MAP[fileType]);
+          }
+        };
+        const replaceNodeAndInjectCodeVisitor = {
+          /**
+           *  进入时
+           *    1、记录@i18n-ignore注释所在行号
+           *    2、如果是vue文件，判断是否是否存在setup函数（如果存在，记录setup函数节点）
+           */
+          Program: function(node) {
+            isIgnored = createI18nIgnoreChecker(context, node.templateBody);
+            if (fileType === "vue" && isScriptSetup(context)) {
+              enterSetup(node);
+            }
+          },
+          //  选择器匹配setup函数节点
+          'ExportDefaultDeclaration > ObjectExpression > Property[key.name="setup"] > :function': function(node) {
+            if (fileType === "vue" || fileType === "jsx") {
+              enterSetup(node);
+            }
+          },
+          'ExportDefaultDeclaration > ObjectExpression > Property[key.name="setup"] > :function:exit': leaveSetup,
+          'ExportDefaultDeclaration > CallExpression[callee.name="defineComponent"] > ObjectExpression > Property[key.name="setup"] > :function': function(node) {
+            if (fileType === "vue" || fileType === "jsx") {
+              enterSetup(node);
+            }
+          },
+          'ExportDefaultDeclaration > CallExpression[callee.name="defineComponent"] > ObjectExpression > Property[key.name="setup"] > :function:exit': leaveSetup,
+          /**
+           * 退出时，批量进行修复
+           */
+          "Program:exit": async function() {
+            batchFixAll(context, state);
+          }
+        };
+        return context.sourceCode.parserServices.defineTemplateBodyVisitor(
+          collectTemplateChineseTextNodeVisitor,
+          {
+            ...collectScriptChineseTextNodeVisitor,
+            ...replaceNodeAndInjectCodeVisitor
+          },
+          {
+            templateBodyTriggerSelector: "Program"
+            // 执行顺序 Program -> templateBodyVisitor -> scriptBodyVisitor -> Program:exit
+          }
+        );
+      }
+    }
+  }
+};
+var i18n_easy_plugin_default = VuePlugin;
+export {
+  i18n_easy_plugin_default as default
+};

package/esm/eslint/vue/i18n_utils.d.ts

@@ -0,0 +1,65 @@
+import type { Rule } from 'eslint';
+import type { AST } from 'vue-eslint-parser';
+import * as ESTree from 'estree';
+import { TextNode, SetUpNode, CodeType } from '../../type.js';
+/**
+ * @description 创建i18n-ignore注释检查器
+ * @param context - ESLint规则上下文
+ * @param templateBody - Vue模板体节点
+ * @returns 检查节点是否被忽略的函数
+ */
+export declare function createI18nIgnoreChecker(context: Rule.RuleContext, templateBody: AST.VElement & AST.HasConcreteInfo): (node: any) => boolean;
+/**
+ * @description 判断能否注入
+ * @param context - ESLint规则上下文
+ * @param node - Program节点、FunctionExpression节点、ArrowFunctionExpression节点
+ * @param codeType - 代码类型
+ * @returns 是否能注入
+ */
+export declare function callNameNotExist(context: Rule.RuleContext, node: SetUpNode, codeType: Exclude<CodeType, 'template'>): boolean;
+/**
+ *  1、不存在节点返回null
+ *  2、存在import节点，返回最后一个import节点
+ *  3、不存在import节点，返回第一个非import节点
+ * @description 获取最后一个 import 或第一个非 import 节点
+ * @param context - ESLint规则上下文
+ * @returns 最后一个 import 节点或第一个非 import 节点或 null
+ */
+export declare function getLastImportOrFirstNotImportNode(context: Rule.RuleContext): {
+    node: ESTree.Node;
+    type: string;
+} | null;
+/**
+ * @description 获取hooks注入节点
+ * @param context - ESLint规则上下文
+ * @param node - BlockStatement节点或Program节点
+ * @returns 注入节点或null
+ */
+export declare function getInjectNode(context: Rule.RuleContext, node: ESTree.BlockStatement | ESTree.Program): ESTree.ModuleDeclaration | ESTree.Statement | ESTree.Comment;
+/**
+ *  判断能否收集操作节点
+ *  排除：
+ *      1、使用@i18n-ignore注释的节点
+ *      2、未使用中文的节点
+ * @description 判断能否收集操作节点
+ * @param node - TextNode节点
+ * @param isIgnored - 判断节点是否被忽略的函数
+ * @returns 是否能收集操作节点
+ */
+export declare function canCollectOperateNodes(node: TextNode, isIgnored: (n: TextNode) => boolean): boolean;
+/**
+ * @description 获取节点前的空格
+ * @param context - ESLint规则上下文
+ * @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;
+export declare function isScriptSetup(context: Rule.RuleContext): boolean;