i18n-easy 1.0.0

package/lib/eslint/vue/i18n_utils.js

@@ -0,0 +1,164 @@
+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/eslint/vue/i18n_utils.ts
+var i18n_utils_exports = {};
+__export(i18n_utils_exports, {
+  callNameNotExist: () => callNameNotExist,
+  canCollectOperateNodes: () => canCollectOperateNodes,
+  createI18nIgnoreChecker: () => createI18nIgnoreChecker,
+  getI18nCallMethod: () => getI18nCallMethod,
+  getInjectNode: () => getInjectNode,
+  getLastImportOrFirstNotImportNode: () => getLastImportOrFirstNotImportNode,
+  getLeadingSpaces: () => getLeadingSpaces,
+  isScriptSetup: () => isScriptSetup
+});
+module.exports = __toCommonJS(i18n_utils_exports);
+var import_utils = require("../../utils.js");
+function createI18nIgnoreChecker(context, templateBody) {
+  const ignoreLines = [];
+  const jsComments = context.sourceCode.getAllComments();
+  const templateComments = templateBody ? templateBody.comments : [];
+  for (const comment of [...jsComments, ...templateComments]) {
+    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 (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+    return context.sourceCode.getScope(node);
+  }
+  return null;
+}
+function callNameNotExist(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 "VText":
+      if (!(0, import_utils.hasChineseChar)(node.value)) return false;
+      break;
+    case "VAttribute":
+      if (!node.value) return false;
+      if (node.value.type !== "VLiteral") return false;
+      if (!(0, import_utils.hasChineseChar)(node.value.value)) return false;
+      break;
+    case "TemplateLiteral":
+      if (!node.quasis.some((q) => (0, import_utils.hasChineseChar)(q.value.cooked))) return false;
+      break;
+    case "Literal":
+      if (!(0, import_utils.hasChineseChar)(node.value)) return false;
+      break;
+    case "JSXText":
+      if (!(0, import_utils.hasChineseChar)(node.value)) return false;
+      break;
+  }
+  return true;
+}
+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}')`;
+}
+function isScriptSetup(context) {
+  var _a, _b;
+  const df = (_b = (_a = context.sourceCode.parserServices).getDocumentFragment) == null ? void 0 : _b.call(_a);
+  if (!df) {
+    return false;
+  }
+  const scripts = df.children.filter((e) => e.type === "VElement" && e.name === "script");
+  return scripts.some((node) => node.startTag.attributes.some((i) => i.key.name = "setup"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callNameNotExist,
+  canCollectOperateNodes,
+  createI18nIgnoreChecker,
+  getI18nCallMethod,
+  getInjectNode,
+  getLastImportOrFirstNotImportNode,
+  getLeadingSpaces,
+  isScriptSetup
+});

package/lib/eslint/vue/report_and_fix.js

@@ -0,0 +1,203 @@
+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/eslint/vue/report_and_fix.ts
+var report_and_fix_exports = {};
+__export(report_and_fix_exports, {
+  batchFixAll: () => batchFixAll
+});
+module.exports = __toCommonJS(report_and_fix_exports);
+var import_i18n_utils = require("./i18n_utils.js");
+var import_key_map = __toESM(require("../../key_map.js"));
+var keyMapper = import_key_map.default.getInstance();
+function generateReplaceKeyFixFun(context, node, codeType) {
+  const { callMethodName } = context.settings.i18nInfo[codeType] || {};
+  if (!callMethodName) {
+    return null;
+  }
+  switch (node.type) {
+    case "VText":
+      return (fixer) => {
+        const value = node.value;
+        const key = keyMapper.generateKey(value);
+        const replaceStr = value.replace(value.trim(), `{{ ${(0, import_i18n_utils.getI18nCallMethod)(callMethodName, key)} }}`);
+        return fixer.replaceTextRange(node.range, replaceStr);
+      };
+    case "VAttribute":
+      return (fixer) => {
+        const value = node.value.value;
+        const key = keyMapper.generateKey(value);
+        const afterReplaceKey = value.replace(value.trim(), key);
+        const replaceStr = `:${node.key.name}="${(0, import_i18n_utils.getI18nCallMethod)(callMethodName, afterReplaceKey)}"`;
+        return fixer.replaceTextRange(node.range, replaceStr);
+      };
+    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 = `${(0, import_i18n_utils.getI18nCallMethod)(callMethodName, afterReplaceKey, paramsStr)}`;
+          return fixer.replaceTextRange(node.range, replaceStr2);
+        }
+        const replaceStr = `${(0, import_i18n_utils.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" ? `{ ${(0, import_i18n_utils.getI18nCallMethod)(callMethodName, key)} }` : `${(0, import_i18n_utils.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);
+        const replaceStr = value.replace(value.trim(), `{ ${(0, import_i18n_utils.getI18nCallMethod)(callMethodName, key)} }`);
+        return fixer.replaceTextRange(node.range, replaceStr);
+      };
+    default:
+      return null;
+  }
+}
+function generateInjectImportFixFun(context, codeType) {
+  const { injectImport } = context.settings.i18nInfo[codeType] || {};
+  if (!injectImport) return null;
+  return (fixer) => {
+    const res = (0, import_i18n_utils.getLastImportOrFirstNotImportNode)(context);
+    if (!res) return null;
+    const { node: injectNode, type } = res;
+    const indent = (0, import_i18n_utils.getLeadingSpaces)(context, injectNode);
+    if (type === "firstNonImport") {
+      return fixer.insertTextBeforeRange(injectNode.range, `${injectImport}
+${indent}`);
+    }
+    return fixer.insertTextAfterRange(injectNode.range, `
+${indent}${injectImport}`);
+  };
+}
+function generateInjectCodeToTopLevelFixFun(context, codeType) {
+  const { injectCodeToTopLevel } = context.settings.i18nInfo[codeType] || {};
+  if (!injectCodeToTopLevel) return null;
+  return (fixer) => {
+    const res = (0, import_i18n_utils.getLastImportOrFirstNotImportNode)(context);
+    if (!res) return null;
+    const { node: injectNode, type } = res;
+    const indent = (0, import_i18n_utils.getLeadingSpaces)(context, injectNode);
+    if (type === "firstNonImport") {
+      return fixer.insertTextBeforeRange(injectNode.range, `${injectCodeToTopLevel}
+${indent}`);
+    }
+    return fixer.insertTextAfterRange(injectNode.range, `
+${indent}${injectCodeToTopLevel}`);
+  };
+}
+function generateInjectHooksCallFixFun(context, node, codeType) {
+  const { injectHooksCall } = context.settings.i18nInfo[codeType] || {};
+  if (!injectHooksCall) return null;
+  return (fixer) => {
+    const blockStatementNode = (node == null ? void 0 : node.type) === "Program" ? node : node == null ? void 0 : node.body;
+    const injectNode = (0, import_i18n_utils.getInjectNode)(context, blockStatementNode);
+    const indent = (0, import_i18n_utils.getLeadingSpaces)(context, injectNode);
+    return fixer.insertTextBeforeRange(injectNode.range, `${injectHooksCall}
+${indent}`);
+  };
+}
+function batchFixAll(context, state) {
+  const allNodeList = [...state.templateTextNodeList, ...state.scriptTextNodeList, ...state.jsTextNodeList, ...state.jsxTextNodeList];
+  if (!allNodeList.length) return;
+  const textNodeFixes = [];
+  const injectImportFixes = [];
+  const injectCodeToTopLevelFixes = [];
+  const injectHooksCallFixes = [];
+  const injectFlag = /* @__PURE__ */ new Map();
+  for (const item of allNodeList) {
+    textNodeFixes.push(generateReplaceKeyFixFun(context, item.textNode, item.inSetup ? "scriptSetup" : item.codeType));
+    switch (item.codeType) {
+      case "script":
+        if (item.inSetup) {
+          if ((0, import_i18n_utils.callNameNotExist)(context, item.setUpNode, "scriptSetup") && !injectFlag.has("scriptSetup")) {
+            injectFlag.set("scriptSetup", true);
+            injectHooksCallFixes.push(generateInjectHooksCallFixFun(context, item.setUpNode, "scriptSetup"));
+            injectImportFixes.push(generateInjectImportFixFun(context, "scriptSetup"));
+            injectCodeToTopLevelFixes.push(generateInjectCodeToTopLevelFixFun(context, "scriptSetup"));
+          }
+          break;
+        }
+        if ((0, import_i18n_utils.callNameNotExist)(context, context.sourceCode.ast, "script") && !injectFlag.has("script")) {
+          injectFlag.set("script", true);
+          injectImportFixes.push(generateInjectImportFixFun(context, "script"));
+          injectCodeToTopLevelFixes.push(generateInjectCodeToTopLevelFixFun(context, "script"));
+        }
+        break;
+      case "jsx":
+        if (item.inSetup) {
+          if ((0, import_i18n_utils.callNameNotExist)(context, item.setUpNode, "scriptSetup") && !injectFlag.has("scriptSetup")) {
+            injectFlag.set("scriptSetup", true);
+            injectHooksCallFixes.push(generateInjectHooksCallFixFun(context, item.setUpNode, "scriptSetup"));
+            injectImportFixes.push(generateInjectImportFixFun(context, "scriptSetup"));
+            injectCodeToTopLevelFixes.push(generateInjectCodeToTopLevelFixFun(context, "scriptSetup"));
+          }
+          break;
+        }
+        if ((0, import_i18n_utils.callNameNotExist)(context, context.sourceCode.ast, "jsx") && !injectFlag.has("jsx")) {
+          injectFlag.set("jsx", true);
+          injectImportFixes.push(generateInjectImportFixFun(context, "jsx"));
+          injectCodeToTopLevelFixes.push(generateInjectCodeToTopLevelFixFun(context, "jsx"));
+        }
+        break;
+      case "js":
+        if ((0, import_i18n_utils.callNameNotExist)(context, context.sourceCode.ast, "js") && !injectFlag.has("js")) {
+          injectFlag.set("js", true);
+          injectImportFixes.push(generateInjectImportFixFun(context, "js"));
+          injectCodeToTopLevelFixes.push(generateInjectCodeToTopLevelFixFun(context, "js"));
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  const fixes = [...textNodeFixes, ...injectImportFixes, ...injectCodeToTopLevelFixes, ...injectHooksCallFixes].filter((item) => item !== null);
+  if (!fixes.length) return;
+  context.report({
+    loc: context.sourceCode.ast.loc,
+    message: "存在中文字符，可以进行国际化替换",
+    fix: (fixer) => {
+      return fixes.map((f) => f(fixer)).filter(Boolean);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  batchFixAll
+});

package/lib/file_processor_utils.js

@@ -0,0 +1,109 @@
+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/file_processor_utils.ts
+var file_processor_utils_exports = {};
+__export(file_processor_utils_exports, {
+  fileExists: () => fileExists,
+  getFileContent: () => getFileContent,
+  getFileType: () => getFileType,
+  getModifiedFiles: () => getModifiedFiles,
+  isDescendant: () => isDescendant,
+  readFile: () => readFile,
+  writeFile: () => writeFile,
+  writeI18nFile: () => writeI18nFile
+});
+module.exports = __toCommonJS(file_processor_utils_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_const = require("./assets/const.js");
+var import_json5 = __toESM(require("json5"));
+var import_simple_git = require("simple-git");
+async function getModifiedFiles() {
+  const raw = await (0, import_simple_git.simpleGit)().diff(["--cached", "--name-only", "--diff-filter=AM"]);
+  const files = raw.split("\n").filter(Boolean);
+  return files.map((item) => import_node_path.default.resolve(item));
+}
+async function readFile(filePath) {
+  return await import_node_fs.promises.readFile(filePath, "utf8");
+}
+function getFileType(filePath) {
+  return import_node_path.default.extname(filePath).slice(1);
+}
+async function writeFile(filePath, content) {
+  await import_node_fs.promises.writeFile(import_node_path.default.resolve(filePath), content, "utf8");
+}
+async function fileExists(filePath) {
+  return Promise.resolve(import_node_fs.promises.stat(import_node_path.default.resolve(filePath)).then(() => true).catch(() => false));
+}
+async function writeI18nFile(filePath, content) {
+  const fileType = getFileType(filePath);
+  if (!["js", "ts", "json"].includes(fileType)) {
+    throw new Error(`国际化语言文件${filePath}}仅支持 JS、TS、JSON格式`);
+  }
+  try {
+    const { exportPrefix, code } = await getFileContent(filePath, fileType);
+    const allContent = Object.assign(code, content);
+    await writeFile(filePath, `${exportPrefix} ${JSON.stringify(allContent, null, 2)}`);
+  } catch (error) {
+    throw new Error(`国际化语言文件${filePath}写入内容失败，${error}`);
+  }
+}
+async function getFileContent(filePath, fileType) {
+  const fullPath = import_node_path.default.resolve(filePath);
+  const isExist = await fileExists(filePath);
+  const exportPrefix = fileType === "json" ? "" : "export default";
+  if (!isExist) {
+    return { exportPrefix, code: {} };
+  }
+  const code = await readFile(fullPath);
+  const result = code.match(import_const.checkReg);
+  if (!result) {
+    return { exportPrefix, code: {} };
+  }
+  if (fileType === "json") {
+    return { exportPrefix: "", code: JSON.parse(code) };
+  }
+  return { exportPrefix: result[1], code: import_json5.default.parse(result[2]) };
+}
+function isDescendant(file, dir) {
+  const f = import_node_path.default.resolve(file).toLowerCase();
+  const d = import_node_path.default.resolve(dir).toLowerCase();
+  return f !== d && f.startsWith(d + "/");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileExists,
+  getFileContent,
+  getFileType,
+  getModifiedFiles,
+  isDescendant,
+  readFile,
+  writeFile,
+  writeI18nFile
+});

package/lib/i18n_easy.js

@@ -0,0 +1,205 @@
+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/i18n_easy.ts
+var i18n_easy_exports = {};
+__export(i18n_easy_exports, {
+  I18nEasy: () => I18nEasy
+});
+module.exports = __toCommonJS(i18n_easy_exports);
+var import_const = require("./assets/const.js");
+var import_key_map = __toESM(require("./key_map.js"));
+var import_ast_transformer = require("./ast_transformer.js");
+var import_node_path = __toESM(require("node:path"));
+var import_utils = require("./utils.js");
+var import_file_processor_utils = require("./file_processor_utils.js");
+var import_progressBus = require("./progressBus.js");
+var import_translate = __toESM(require("./translate.js"));
+var I18nEasy = class {
+  /**
+   * vue框架中将文件内容转换成i18n写法并翻译
+   * @param filePath 文件绝对路径
+   * @param options 配置项
+   */
+  async fileToI18nVue(filePath, options) {
+    const { keyType = "pinyin", i18nInfo, customIgnore } = options;
+    const fileType = (0, import_file_processor_utils.getFileType)(filePath);
+    if (!(0, import_utils.isSupportFileType)(fileType, "vue")) {
+      throw new Error(`${filePath}出错了，不支持的文件类型：${fileType}`);
+    }
+    const fileContent = await (0, import_file_processor_utils.readFile)(filePath);
+    const isVueScriptSrc = await (0, import_utils.isVueScriptSrcImport)(filePath, fileType);
+    const astTransformer = new import_ast_transformer.AstTransformer();
+    const keyMapper = import_key_map.default.getInstance();
+    keyMapper.setKeyType(keyType);
+    keyMapper.clearCharMap();
+    const fixedResult = astTransformer.convertFileContent({
+      fileContent,
+      fileName: import_node_path.default.basename(filePath),
+      fileType: isVueScriptSrc ? "vue" : fileType,
+      type: "vue",
+      i18nInfo,
+      customIgnore
+    });
+    return {
+      filePath,
+      oldFileContent: fileContent,
+      keyValueMap: Array.from(keyMapper.charList),
+      ...fixedResult
+    };
+  }
+  /**
+   * react框架中将文件内容转换成i18n写法并翻译
+   * @param filePath 文件绝对路径
+   * @param options 配置项
+   */
+  async fileToI18nReact(filePath, options) {
+    const { keyType = "pinyin", i18nInfo } = options;
+    const fileType = (0, import_file_processor_utils.getFileType)(filePath);
+    if (!(0, import_utils.isSupportFileType)(fileType, "react")) {
+      throw new Error(`${filePath}出错了，不支持的文件类型：${fileType}`);
+    }
+    const fileContent = await (0, import_file_processor_utils.readFile)(filePath);
+    const astTransformer = new import_ast_transformer.AstTransformer();
+    const keyMapper = import_key_map.default.getInstance();
+    keyMapper.setKeyType(keyType);
+    keyMapper.clearCharMap();
+    const fixedResult = astTransformer.convertFileContent({
+      fileContent,
+      fileName: import_node_path.default.basename(filePath),
+      fileType,
+      type: "react",
+      i18nInfo
+    });
+    return {
+      filePath,
+      oldFileContent: fileContent,
+      keyValueMap: Array.from(keyMapper.charList),
+      ...fixedResult
+    };
+  }
+  /**
+   * 将文件内容转换成i18n写法
+   * @param filePath 文件绝对路径
+   * @param options 配置项
+   */
+  async fileToI18n(filePath, options) {
+    const { type } = options;
+    if (type === "vue") {
+      return this.fileToI18nVue(filePath, options);
+    } else if (type === "react") {
+      return this.fileToI18nReact(filePath, options);
+    } else {
+      throw new Error(`不支持的框架类型：${type}`);
+    }
+  }
+  /**
+   * 将文件内容转换成i18n写法并翻译
+   * @param filePath 文件绝对路径
+   * @param options 配置项
+   */
+  async fileToI18nAndTranslate(filePath, options) {
+    const { type, keyType = "pinyin", i18nInfo, lang, apiKey } = options;
+    const result = await this.fileToI18n(filePath, { type, keyType, i18nInfo });
+    const translator = import_translate.default.getInstance();
+    translator.setApiKey(apiKey);
+    const arr = result.fixed ? result.keyValueMap : [];
+    const translateResult = await translator.translate(arr, lang);
+    return {
+      ...result,
+      translateResult
+    };
+  }
+  /**
+   * 将文件内容转换成i18n写法并翻译，支持批量
+   * @param filePath 文件绝对路径
+   * @param options 配置项
+   */
+  async fileToI18nAndTranslateBatch(filePaths, options) {
+    const { type, keyType = "pinyin", i18nInfo, lang, apiKey, customIgnore } = options;
+    const result = await Promise.all(filePaths.map((filePath) => this.fileToI18n(filePath, { type, keyType, i18nInfo, customIgnore })));
+    const translator = import_translate.default.getInstance();
+    translator.setApiKey(apiKey);
+    const arr = result.filter((item) => item.fixed).flatMap((i) => i.keyValueMap);
+    const translateResult = await translator.translate(arr, lang);
+    return {
+      transformResult: result,
+      translateResult
+    };
+  }
+  /**
+   * @description 获取需要处理的文件信息
+   * @returns 文件信息
+   */
+  async getPendingFiles() {
+    const filePaths = await (0, import_file_processor_utils.getModifiedFiles)();
+    if (filePaths.length === 0) {
+      (0, import_progressBus.log)(`暂存区暂无需要处理的文件`, "info");
+      return;
+    }
+    const configContext = await (0, import_utils.searchFileContent)(import_node_path.default.resolve(), import_const.configFileNames);
+    if (!configContext) {
+      (0, import_progressBus.log)(`未在目录${import_node_path.default.resolve()}下找到配置文件`, "info");
+      return;
+    }
+    const { apiKey, projects } = configContext;
+    const result = projects.map((item) => {
+      const projectPath = import_node_path.default.resolve(item.projectPath);
+      const files = filePaths.filter((filePath) => (0, import_file_processor_utils.isDescendant)(filePath, projectPath) && (0, import_utils.isSupportFileType)((0, import_file_processor_utils.getFileType)(filePath), item.type));
+      return { ...item, files, projectPath, apiKey };
+    });
+    return result;
+  }
+  /**
+   * @description 对git暂存区的文件进行i18n转换和翻译 并将翻译结果写入语言文件
+   * @returns {Promise<void>}
+   */
+  async transformModifiedFiles() {
+    (0, import_progressBus.log)(`提示：对于vue框架，仅支持vue、js、jsx、ts、tsx文件，对于react框架；仅支持js、jsx、ts、tsx文件，其他文件类型将被忽略...
+`, "info");
+    const pendingFiles = await this.getPendingFiles();
+    if (!pendingFiles) {
+      return;
+    }
+    for (const item of pendingFiles) {
+      const { projectPath, files, apiKey, i18nInfo, lang, type, keyType, customIgnore } = item;
+      (0, import_progressBus.log)(`开始处理目录${projectPath}下文件...
+`, "info");
+      const { translateResult, transformResult } = await this.fileToI18nAndTranslateBatch(files, { i18nInfo, apiKey, lang: lang.map((i) => i.name), type, keyType, customIgnore });
+      const fixed = transformResult.filter((item2) => item2.fixed);
+      const notFixed = transformResult.filter((item2) => !item2.fixed);
+      await Promise.all(fixed.map(({ filePath, newFileContent }) => (0, import_file_processor_utils.writeFile)(filePath, newFileContent)));
+      await Promise.all(lang.map(({ name, i18nFilePath }) => translateResult[name] ? (0, import_file_processor_utils.writeI18nFile)(i18nFilePath, translateResult[name]) : null).filter(Boolean));
+      (0, import_progressBus.log)(`目录${projectPath}下支持的文件已处理完成；共${files.length}个文件，已处理${fixed.length}个文件，未处理${notFixed.length}个文件...`, "success");
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  I18nEasy
+});