i18n-easy 1.0.0

package/esm/key_map.js

@@ -0,0 +1,51 @@
+// src/key_map.ts
+import { generateKeyByKeyType } from "./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 = 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;
+  }
+};
+export {
+  KeyMap as default
+};

package/esm/patch.d.ts

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

package/esm/progressBus.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'events';
+import { LogStatus } from './type.js';
+/** 全局单例事件总线 */
+export declare const progressBus: EventEmitter<[never]>;
+/** 内部通用日志函数：既 console.log，也 emit */
+export declare function log(msg: string, status: LogStatus): void;

package/esm/progressBus.js

@@ -0,0 +1,25 @@
+// src/progressBus.ts
+import { EventEmitter } from "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 EventEmitter();
+function colorLog(msg, status) {
+  console.log(`${statusColorMap[status]}${msg}${colors.reset}`);
+}
+function log(msg, status) {
+  colorLog(msg, status);
+  progressBus.emit("log", msg, status);
+}
+export {
+  log,
+  progressBus
+};

package/esm/translate.d.ts

@@ -0,0 +1,34 @@
+export default class Translate {
+    private endpoint;
+    private apiKey;
+    private static instance;
+    private constructor();
+    static getInstance(): Translate;
+    /**
+     * 构建微软翻译API请求配置
+     * @param originalTextArr 原始文本数组，每个元素为{ text: string }
+     * @param lang 目标语言数组
+     * @returns
+     */
+    private buildRequestConfig;
+    /**
+     * 处理微软翻译API响应数据
+     * @param responseData 翻译API响应数据，每个元素为{ translations: { text: string }[] }
+     * @param originalTextArr 原始文本数组，每个元素为[ key: string, text: string ]
+     * @param lang 目标语言数组
+     * @returns 翻译结果，格式为{ language: { key: text } }
+     */
+    private processResponse;
+    /**
+     * 翻译中文为其他指定语言
+     * @param originalTextArr 原始文本数组，每个元素为[ key: string, text: string ]
+     * @param lang 目标语言数组
+     * @returns 翻译结果，格式为{ language: { key: text } }
+     */
+    translate(originalTextArr: [string, string][], lang: string[]): Promise<Record<string, Record<string, string>>>;
+    /**
+     * 设置微软翻译API密钥
+     * @param apiKey 微软翻译API密钥
+     */
+    setApiKey(apiKey: string): void;
+}

package/esm/translate.js

@@ -0,0 +1,107 @@
+// src/translate.ts
+import { v4 as uuidv4 } from "uuid";
+import { customTranslation } from "./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": uuidv4().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) => 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;
+  }
+};
+export {
+  Translate as default
+};

package/esm/type.d.ts

@@ -0,0 +1,94 @@
+import type { AST } from 'vue-eslint-parser';
+import * as ESTree from 'estree';
+import type { Rule } from 'eslint';
+export declare type Framework = 'vue' | 'react';
+export declare type BaseCodeType = 'vue' | 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'template' | 'script' | 'scriptSetup';
+export interface SupportFileMap {
+    vue: Extract<BaseCodeType, 'vue' | 'js' | 'jsx' | 'ts' | 'tsx'>;
+    react: Extract<BaseCodeType, 'js' | 'jsx' | 'ts' | 'tsx'>;
+}
+export interface I18nInfoType {
+    template?: {
+        callMethodName: string;
+    };
+    script?: {
+        callMethodName: string;
+        injectImport?: string;
+        injectCodeToTopLevel?: string;
+    };
+    scriptSetup?: {
+        callMethodName: string;
+        injectImport?: string;
+        injectCodeToTopLevel?: string;
+        injectHooksCall?: string;
+    };
+    js?: {
+        callMethodName: string;
+        injectImport?: string;
+        injectCodeToTopLevel?: string;
+    };
+    jsx?: {
+        callMethodName: string;
+        injectImport?: string;
+        injectCodeToTopLevel?: string;
+    };
+}
+export interface LangType {
+    name: string;
+    i18nFilePath: string;
+}
+export interface JSXText extends ESTree.BaseNode, ESTree.BaseExpression {
+    type: 'JSXText';
+    value: string;
+    raw: string | undefined;
+}
+export declare type TextNode = AST.VText | AST.VAttribute | ESTree.TemplateLiteral | (ESTree.Literal & Rule.NodeParentExtension) | JSXText;
+export declare type TextNodeType = 'VText' | 'VAttribute' | 'TemplateLiteral' | 'Literal' | 'JSXText';
+export declare type SetUpNode = ESTree.FunctionExpression | ESTree.ArrowFunctionExpression | ESTree.Program | null;
+export declare type CodeType = Extract<BaseCodeType, 'js' | 'jsx' | 'script' | 'scriptSetup' | 'template'>;
+interface CollectItemType {
+    textNode: TextNode;
+    codeType: Extract<BaseCodeType, 'js' | 'jsx' | 'script' | 'template'>;
+    setUpNode: SetUpNode;
+    inSetup: boolean;
+}
+export interface CollectListType {
+    templateTextNodeList: CollectItemType[];
+    scriptTextNodeList: CollectItemType[];
+    jsTextNodeList: CollectItemType[];
+    jsxTextNodeList: CollectItemType[];
+}
+export interface NodeListener extends Rule.NodeListener {
+    VText: (node: AST.VText) => void;
+    VAttribute: (node: AST.VAttribute) => void;
+    JSXText: (node: JSXText) => void;
+    [key: string]: ((...args: any[]) => void) | undefined;
+}
+export interface ReactCollectItemType {
+    textNode: ESTree.TemplateLiteral | (ESTree.Literal & Rule.NodeParentExtension) | JSXText;
+    componentNode: ESTree.FunctionDeclaration | ESTree.VariableDeclarator | null;
+    programNode: ESTree.Program | null;
+    inComp: boolean;
+}
+export interface ReactCollectListType {
+    inComponent: ReactCollectItemType[];
+    outComponent: ReactCollectItemType[];
+}
+export declare type ReactInjectCodeType = ESTree.FunctionDeclaration | ESTree.VariableDeclarator | ESTree.Program;
+export interface ReactI18nInfoType {
+    js?: {
+        callMethodName: string;
+        injectImport?: string;
+        injectCodeToTopLevel?: string;
+    };
+    jsx?: {
+        callMethodName: string;
+        injectImport?: string;
+        injectCodeToTopLevel?: string;
+        injectHooksCall?: string;
+    };
+}
+export declare type ReactCodeType = Extract<BaseCodeType, 'js' | 'jsx'>;
+export declare type LogStatus = 'success' | 'info' | 'fail';
+export declare type KeyType = 'hash' | 'pinyin' | 'pinyinWithNumber';
+export {};

package/esm/utils.d.ts

@@ -0,0 +1,54 @@
+import { Framework, SupportFileMap, KeyType, LangType, I18nInfoType, ReactI18nInfoType, TextNode, ReactCollectItemType } from './type.js';
+import type { Rule } from 'eslint';
+export interface Config<T extends Framework> {
+    projects: {
+        projectPath: string;
+        lang: LangType[];
+        i18nInfo: T extends 'vue' ? I18nInfoType : ReactI18nInfoType;
+        keyType: KeyType;
+        type: T;
+        customIgnore?: (node: T extends 'vue' ? TextNode : ReactCollectItemType['textNode'], context: Rule.RuleContext) => boolean;
+    }[];
+    apiKey: string;
+}
+/**
+ * @description 判断字符串是否包含中文
+ * @param str 字符串
+ * @returns {boolean} 是否包含中文
+ */
+export declare function hasChineseChar(str: string | undefined | null): boolean;
+/**
+ * @description 生成对应字符串的 hash 值或拼音值
+ * @param char 字符串
+ * @param keyType 键类型
+ * @returns {string} hash 值或拼音值
+ */
+export declare function generateKeyByKeyType(char: string, keyType: KeyType): string;
+/**
+ * @description 判断是否为vue文件的script src导入
+ * @param filePath 文件路径
+ * @param fileType 文件类型
+ * @returns {Promise<boolean>} 是否为vue文件的script src导入
+ */
+export declare function isVueScriptSrcImport(filePath: string, fileType: string): Promise<boolean>;
+/**
+ * @description 判断文件类型是否支持转换
+ * @param fileType 文件类型
+ * @param framework 框架类型
+ * @returns {boolean} 是否支持转换
+ */
+export declare function isSupportFileType<F extends Framework>(fileType: string, framework: F): fileType is SupportFileMap[F];
+/**
+ * @description 在指定目录下查重指定名称文件，并加载文件导出内容
+ * @param dirPath 目录路径
+ * @param searchPlaces 文件名称列表
+ * @returns {Promise<any | null>} 文件内容
+ */
+export declare function searchFileContent<T extends Framework>(dirPath: string, searchPlaces: string[]): Promise<Config<T> | null>;
+/**
+ * @description 配置辅助函数
+ * @param config  配置项
+ * @returns 配置项
+ */
+export declare function defineConfig<T extends Framework>(config: Config<T>): Config<T>;
+export declare function customTranslation(source: string, translation: string): string;

package/esm/utils.js

@@ -0,0 +1,102 @@
+// src/utils.ts
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { glob } from "glob";
+import { parse } from "@vue/compiler-sfc";
+import { pinyin, addDict } from "pinyin-pro";
+import ModernChineseDict from "@pinyin-pro/data/modern";
+import { cosmiconfig, defaultLoaders } from "cosmiconfig";
+addDict(ModernChineseDict);
+function hasChineseChar(str) {
+  if (!str) {
+    return false;
+  }
+  return /[\u4e00-\u9fa5]/.test(str);
+}
+function generateHash(char) {
+  const hash = 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 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 glob("*.vue", { cwd: path.dirname(filePath), absolute: true, nodir: true });
+  for (const file of vueFiles) {
+    const code = await fs.readFile(file, "utf8");
+    const { descriptor } = parse(code);
+    const { script } = descriptor;
+    if ((script == null ? void 0 : script.src) && path.resolve(path.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 = cosmiconfig("", {
+    searchStrategy: "none",
+    searchPlaces,
+    loaders: {
+      ".json": defaultLoaders[".json"],
+      // 保持默认 JSON 加载器
+      ".js": defaultLoaders[".js"],
+      // 保持默认 JS 加载器
+      ".mjs": defaultLoaders[".mjs"],
+      // 保持默认 MJS 加载器
+      ".cjs": defaultLoaders[".cjs"],
+      // 保持默认 CJS 加载器
+      ".ts": defaultLoaders[".ts"],
+      // 保持默认 TS 加载器'
+      noExt: 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>`;
+}
+export {
+  customTranslation,
+  defineConfig,
+  generateKeyByKeyType,
+  hasChineseChar,
+  isSupportFileType,
+  isVueScriptSrcImport,
+  searchFileContent
+};

package/lib/assets/const.js

@@ -0,0 +1,32 @@
+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/assets/const.ts
+var const_exports = {};
+__export(const_exports, {
+  checkReg: () => checkReg,
+  configFileNames: () => configFileNames
+});
+module.exports = __toCommonJS(const_exports);
+var configFileNames = ["i18n_easy.mjs", "i18n_easy.cjs", "i18n_easy.js", "i18n_easy.ts", "i18n_easy.json"];
+var checkReg = /(module\.exports\s*=\s*|export\s*default\s*)?({[\s\S]*})/;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkReg,
+  configFileNames
+});

package/lib/ast_transformer.js

@@ -0,0 +1,88 @@
+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/ast_transformer.ts
+var ast_transformer_exports = {};
+__export(ast_transformer_exports, {
+  AstTransformer: () => AstTransformer
+});
+module.exports = __toCommonJS(ast_transformer_exports);
+var import_eslint = require("eslint");
+var import_i18n_easy_plugin = __toESM(require("./eslint/vue/i18n_easy_plugin.js"));
+var import_i18n_easy_plugin2 = __toESM(require("./eslint/react/i18n_easy_plugin.js"));
+var vueParser = __toESM(require("vue-eslint-parser"));
+var espree = __toESM(require("espree"));
+var import_parser = __toESM(require("@typescript-eslint/parser"));
+var AstTransformer = class {
+  linter;
+  constructor() {
+    this.linter = new import_eslint.Linter();
+  }
+  // 转换文件内容
+  convertFileContent(props) {
+    const { fileContent, fileType, fileName, i18nInfo, type, customIgnore } = props;
+    const settings = { i18nInfo, fileType, customIgnore };
+    const parserOptions = {
+      ecmaFeatures: { jsx: true },
+      parser: { js: espree, jsx: espree, ts: import_parser.default, tsx: import_parser.default }
+    };
+    const vueConfig = {
+      files: ["*.vue", "*.js", "*.jsx", "*.ts", "*.tsx"],
+      plugins: { i18nEasyVue: import_i18n_easy_plugin.default },
+      languageOptions: {
+        parser: vueParser,
+        parserOptions
+      },
+      rules: {
+        "i18nEasyVue/i18n-transform": "error"
+      },
+      settings
+    };
+    const reactConfig = {
+      files: ["*.js", "*.jsx", "*.ts", "*.tsx"],
+      plugins: { i18nEasyReact: import_i18n_easy_plugin2.default },
+      languageOptions: {
+        parser: espree,
+        parserOptions
+      },
+      rules: { "i18nEasyReact/i18n-transform": "error" },
+      settings
+    };
+    const res = this.linter.verifyAndFix(fileContent, type == "vue" ? vueConfig : reactConfig, fileName);
+    return {
+      newFileContent: res.output,
+      // 转换后的文件内容（如果未应用修复，可能与输入内容相同）
+      fixed: res.fixed
+      // 是否应用了修复
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AstTransformer
+});

package/lib/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+var import_index = require("./index.js");
+new import_index.I18nEasy().transformModifiedFiles();