i18n-easy 1.0.0

package/esm/eslint/vue/i18n_utils.js

@@ -0,0 +1,133 @@
+// src/eslint/vue/i18n_utils.ts
+import { hasChineseChar } from "../../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 (!hasChineseChar(node.value)) return false;
+      break;
+    case "VAttribute":
+      if (!node.value) return false;
+      if (node.value.type !== "VLiteral") return false;
+      if (!hasChineseChar(node.value.value)) return false;
+      break;
+    case "TemplateLiteral":
+      if (!node.quasis.some((q) => hasChineseChar(q.value.cooked))) return false;
+      break;
+    case "Literal":
+      if (!hasChineseChar(node.value)) return false;
+      break;
+    case "JSXText":
+      if (!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"));
+}
+export {
+  callNameNotExist,
+  canCollectOperateNodes,
+  createI18nIgnoreChecker,
+  getI18nCallMethod,
+  getInjectNode,
+  getLastImportOrFirstNotImportNode,
+  getLeadingSpaces,
+  isScriptSetup
+};

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

@@ -0,0 +1,8 @@
+import type { Rule } from 'eslint';
+import { CollectListType } from '../../type.js';
+/**
+ * @description 批量执行修复函数 根据收集到节点生成修复函数并执行
+ * @param context - 规则上下文
+ * @param state - 收集到的节点信息
+ */
+export declare function batchFixAll(context: Rule.RuleContext, state: CollectListType): void;

package/esm/eslint/vue/report_and_fix.js

@@ -0,0 +1,169 @@
+// src/eslint/vue/report_and_fix.ts
+import { callNameNotExist, 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 "VText":
+      return (fixer) => {
+        const value = node.value;
+        const key = keyMapper.generateKey(value);
+        const replaceStr = value.replace(value.trim(), `{{ ${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}="${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 = `${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);
+        const replaceStr = value.replace(value.trim(), `{ ${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 = 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 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 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 = getInjectNode(context, blockStatementNode);
+    const indent = 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 (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 (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 (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 (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 (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);
+    }
+  });
+}
+export {
+  batchFixAll
+};

package/esm/file_processor_utils.d.ts

@@ -0,0 +1,14 @@
+import { BaseCodeType } from './type.js';
+declare type LangFileType = Extract<BaseCodeType, 'json' | 'js' | 'ts'>;
+export declare function getModifiedFiles(): Promise<string[]>;
+export declare function readFile(filePath: string): Promise<string>;
+export declare function getFileType(filePath: string): string;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function writeI18nFile(filePath: string, content: Record<string, string>): Promise<void>;
+export declare function getFileContent(filePath: string, fileType: LangFileType): Promise<{
+    exportPrefix: string;
+    code: any;
+}>;
+export declare function isDescendant(file: string, dir: string): boolean;
+export {};

package/esm/file_processor_utils.js

@@ -0,0 +1,68 @@
+// src/file_processor_utils.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { checkReg } from "./assets/const.js";
+import JSON5 from "json5";
+import { simpleGit } from "simple-git";
+async function getModifiedFiles() {
+  const raw = await simpleGit().diff(["--cached", "--name-only", "--diff-filter=AM"]);
+  const files = raw.split("\n").filter(Boolean);
+  return files.map((item) => path.resolve(item));
+}
+async function readFile(filePath) {
+  return await fs.readFile(filePath, "utf8");
+}
+function getFileType(filePath) {
+  return path.extname(filePath).slice(1);
+}
+async function writeFile(filePath, content) {
+  await fs.writeFile(path.resolve(filePath), content, "utf8");
+}
+async function fileExists(filePath) {
+  return Promise.resolve(fs.stat(path.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 = path.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(checkReg);
+  if (!result) {
+    return { exportPrefix, code: {} };
+  }
+  if (fileType === "json") {
+    return { exportPrefix: "", code: JSON.parse(code) };
+  }
+  return { exportPrefix: result[1], code: JSON5.parse(result[2]) };
+}
+function isDescendant(file, dir) {
+  const f = path.resolve(file).toLowerCase();
+  const d = path.resolve(dir).toLowerCase();
+  return f !== d && f.startsWith(d + "/");
+}
+export {
+  fileExists,
+  getFileContent,
+  getFileType,
+  getModifiedFiles,
+  isDescendant,
+  readFile,
+  writeFile,
+  writeI18nFile
+};

package/esm/i18n_easy.d.ts

@@ -0,0 +1,77 @@
+import { Framework, I18nInfoType, KeyType, ReactCollectItemType, ReactI18nInfoType, TextNode } from './type.js';
+import type { Rule } from 'eslint';
+interface FileToI18nConfig<T extends Framework> {
+    type: T;
+    keyType?: KeyType;
+    i18nInfo: T extends 'vue' ? I18nInfoType : ReactI18nInfoType;
+    customIgnore?: (node: T extends 'vue' ? TextNode : ReactCollectItemType['textNode'], context: Rule.RuleContext) => boolean;
+}
+interface FileToI18nAndTranslateConfig<T extends Framework> extends FileToI18nConfig<T> {
+    lang: string[];
+    apiKey: string;
+}
+export declare class I18nEasy {
+    /**
+     * vue框架中将文件内容转换成i18n写法并翻译
+     * @param filePath 文件绝对路径
+     * @param options 配置项
+     */
+    private fileToI18nVue;
+    /**
+     * react框架中将文件内容转换成i18n写法并翻译
+     * @param filePath 文件绝对路径
+     * @param options 配置项
+     */
+    private fileToI18nReact;
+    /**
+     * 将文件内容转换成i18n写法
+     * @param filePath 文件绝对路径
+     * @param options 配置项
+     */
+    fileToI18n<T extends Framework>(filePath: string, options: FileToI18nConfig<T>): Promise<{
+        newFileContent: string;
+        fixed: boolean;
+        filePath: string;
+        oldFileContent: string;
+        keyValueMap: [string, string][];
+    }>;
+    /**
+     * 将文件内容转换成i18n写法并翻译
+     * @param filePath 文件绝对路径
+     * @param options 配置项
+     */
+    fileToI18nAndTranslate<T extends Framework>(filePath: string, options: FileToI18nAndTranslateConfig<T>): Promise<{
+        translateResult: Record<string, Record<string, string>>;
+        newFileContent: string;
+        fixed: boolean;
+        filePath: string;
+        oldFileContent: string;
+        keyValueMap: [string, string][];
+    }>;
+    /**
+     * 将文件内容转换成i18n写法并翻译，支持批量
+     * @param filePath 文件绝对路径
+     * @param options 配置项
+     */
+    fileToI18nAndTranslateBatch<T extends Framework>(filePaths: string[], options: FileToI18nAndTranslateConfig<T>): Promise<{
+        transformResult: {
+            newFileContent: string;
+            fixed: boolean;
+            filePath: string;
+            oldFileContent: string;
+            keyValueMap: [string, string][];
+        }[];
+        translateResult: Record<string, Record<string, string>>;
+    }>;
+    /**
+     * @description 获取需要处理的文件信息
+     * @returns 文件信息
+     */
+    private getPendingFiles;
+    /**
+     * @description 对git暂存区的文件进行i18n转换和翻译 并将翻译结果写入语言文件
+     * @returns {Promise<void>}
+     */
+    transformModifiedFiles(): Promise<void>;
+}
+export {};

package/esm/i18n_easy.js

@@ -0,0 +1,171 @@
+// src/i18n_easy.ts
+import { configFileNames } from "./assets/const.js";
+import KeyMap from "./key_map.js";
+import { AstTransformer } from "./ast_transformer.js";
+import path from "node:path";
+import { isSupportFileType, isVueScriptSrcImport, searchFileContent } from "./utils.js";
+import { getFileType, getModifiedFiles, isDescendant, readFile, writeFile, writeI18nFile } from "./file_processor_utils.js";
+import { log } from "./progressBus.js";
+import Translate from "./translate.js";
+var I18nEasy = class {
+  /**
+   * vue框架中将文件内容转换成i18n写法并翻译
+   * @param filePath 文件绝对路径
+   * @param options 配置项
+   */
+  async fileToI18nVue(filePath, options) {
+    const { keyType = "pinyin", i18nInfo, customIgnore } = options;
+    const fileType = getFileType(filePath);
+    if (!isSupportFileType(fileType, "vue")) {
+      throw new Error(`${filePath}出错了，不支持的文件类型：${fileType}`);
+    }
+    const fileContent = await readFile(filePath);
+    const isVueScriptSrc = await isVueScriptSrcImport(filePath, fileType);
+    const astTransformer = new AstTransformer();
+    const keyMapper = KeyMap.getInstance();
+    keyMapper.setKeyType(keyType);
+    keyMapper.clearCharMap();
+    const fixedResult = astTransformer.convertFileContent({
+      fileContent,
+      fileName: path.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 = getFileType(filePath);
+    if (!isSupportFileType(fileType, "react")) {
+      throw new Error(`${filePath}出错了，不支持的文件类型：${fileType}`);
+    }
+    const fileContent = await readFile(filePath);
+    const astTransformer = new AstTransformer();
+    const keyMapper = KeyMap.getInstance();
+    keyMapper.setKeyType(keyType);
+    keyMapper.clearCharMap();
+    const fixedResult = astTransformer.convertFileContent({
+      fileContent,
+      fileName: path.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 = Translate.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 = Translate.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 getModifiedFiles();
+    if (filePaths.length === 0) {
+      log(`暂存区暂无需要处理的文件`, "info");
+      return;
+    }
+    const configContext = await searchFileContent(path.resolve(), configFileNames);
+    if (!configContext) {
+      log(`未在目录${path.resolve()}下找到配置文件`, "info");
+      return;
+    }
+    const { apiKey, projects } = configContext;
+    const result = projects.map((item) => {
+      const projectPath = path.resolve(item.projectPath);
+      const files = filePaths.filter((filePath) => isDescendant(filePath, projectPath) && isSupportFileType(getFileType(filePath), item.type));
+      return { ...item, files, projectPath, apiKey };
+    });
+    return result;
+  }
+  /**
+   * @description 对git暂存区的文件进行i18n转换和翻译 并将翻译结果写入语言文件
+   * @returns {Promise<void>}
+   */
+  async transformModifiedFiles() {
+    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;
+      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 }) => writeFile(filePath, newFileContent)));
+      await Promise.all(lang.map(({ name, i18nFilePath }) => translateResult[name] ? writeI18nFile(i18nFilePath, translateResult[name]) : null).filter(Boolean));
+      log(`目录${projectPath}下支持的文件已处理完成；共${files.length}个文件，已处理${fixed.length}个文件，未处理${notFixed.length}个文件...`, "success");
+    }
+  }
+};
+export {
+  I18nEasy
+};

package/esm/index.d.ts

@@ -0,0 +1,4 @@
+export { I18nEasy } from './i18n_easy.js';
+export { progressBus } from './progressBus.js';
+export { defineConfig } from './utils.js';
+export type { LogStatus } from './type.js';

package/esm/index.js

@@ -0,0 +1,9 @@
+// src/index.ts
+import { I18nEasy } from "./i18n_easy.js";
+import { progressBus } from "./progressBus.js";
+import { defineConfig } from "./utils.js";
+export {
+  I18nEasy,
+  defineConfig,
+  progressBus
+};

package/esm/key_map.d.ts

@@ -0,0 +1,14 @@
+import { KeyType } from './type.js';
+export default class KeyMap {
+    private charMap;
+    private keyType;
+    private static instance;
+    private constructor();
+    static getInstance(): KeyMap;
+    get charList(): Map<string, string>;
+    generateKey(str: string): string;
+    clearCharMap(): void;
+    setCharMap(key: string, value: string): void;
+    isEmpty(): boolean;
+    setKeyType(type: KeyType): void;
+}