i18-fe-automator-beta 1.0.0

package/dist/esm/index.mjs

@@ -0,0 +1,2312 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import inquirer from 'inquirer';
+import { program } from 'commander';
+import request from 'request';
+import { glob } from 'glob';
+import md5 from 'js-md5';
+import CryptoJS from 'crypto-js';
+import ora from 'ora';
+import chalk from 'chalk';
+import xlsx from 'node-xlsx';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import querystring from 'querystring';
+import crypto from 'crypto';
+import { v5 } from 'uuid';
+import { ESLint } from 'eslint';
+import * as espree from 'espree';
+import { createRequire } from 'node:module';
+import stripAnsi from 'strip-ansi';
+import 'shelljs';
+import process$1 from 'child_process';
+import _ from 'lodash';
+import { nanoid } from 'nanoid';
+import request$1 from 'request-promise';
+import 'os';
+import 'console';
+
+function Loading() {
+  this.spinner = ora();
+}
+var Loading$1 = new Loading().spinner;
+
+//加密
+function encrypt(word, keyStr) {
+  keyStr = keyStr ? keyStr : "abcdefgabcdefg12";
+  var key = CryptoJS.enc.Utf8.parse(keyStr); //Latin1 w8m31+Yy/Nw6thPsMpO5fg==
+  var srcs = CryptoJS.enc.Utf8.parse(word);
+  var encrypted = CryptoJS.AES.encrypt(srcs, key, {
+    mode: CryptoJS.mode.ECB,
+    padding: CryptoJS.pad.Pkcs7,
+  });
+  return encrypted.toString();
+}
+
+function login(data) {
+  data.password = encrypt(md5(data.password));
+  const env=data.env;
+  Loading$1.start(`${env}: 登录中...`);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/sys/login`,
+        method: "POST",
+        json: true,
+        body: data,
+      },
+      function (error, response, body) {
+        const res = body;
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`${env}: 登录成功`);
+          const access_token = res.data.access_token;
+          resolve(access_token);
+        } else {
+          Loading$1.fail(`${env}: 登录失败`);
+          console.log(chalk.red(error || res.msg));
+        }
+      }
+    );
+  });
+}
+
+function importExcel({ uploadFilePath, token, env }) {
+  Loading$1.start(`${env}: 导入文件中...`);
+  const stream = fs.createReadStream(uploadFilePath);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/vue-api/api-globalization/api/i18n/importLangExcel`,
+        method: "POST",
+        headers: {
+          contentType: "multipart/form-data",
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+        formData: {
+          file: stream,
+        },
+      },
+      function (error, response, body) {
+        const res = JSON.parse(body);
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`${env}: 导入文件成功`);
+          resolve(true);
+        } else {
+          Loading$1.fail(`${env}: 导入文件失败`);
+          console.log(chalk.red(error || JSON.stringify(res.data)));
+        }
+      }
+    );
+  });
+}
+function readExcel({ uploadFilePath }) {
+  return new Promise((resolve, reject) => {
+    // 读取文件
+    const workSheetsFromFile = xlsx.parse(uploadFilePath);
+    const data = workSheetsFromFile[0].data;
+    //   获取第一行
+    const titleList = data[0];
+    //   获取项目所在的列
+    const projectIndex = titleList.indexOf("项目");
+    if (projectIndex === -1) {
+      console.log(chalk.red("请检查文件是否包含项目列"));
+      return;
+    }
+    // 获取数据
+    const list = data.slice(1);
+    const set = new Set();
+    list.forEach((item) => {
+      if (item[projectIndex]) {
+        set.add(item[projectIndex]);
+      }
+    });
+    // 判断set是否为空
+    if (set.size === 0) {
+      console.log(chalk.red("请检查文件是否包含项目数据"));
+      return;
+    }
+    resolve([...set]);
+  });
+}
+
+function uploadExcel({ data, token, env }) {
+  Loading$1.start(`${env}: 导入项目 ${data.projectList.join()}`);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/vue-api/api-globalization/api/i18n/uploadI18nLangForFront`,
+        method: "POST",
+        json: true,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+        body: data,
+      },
+      function (error, response, body) {
+        const res = body;
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`${env}: 导入项目成功`);
+          resolve(true);
+        } else {
+          Loading$1.fail(`${env}: 导入项目失败`);
+          console.log(chalk.red(error || res.msg || res.message));
+        }
+      }
+    );
+  });
+}
+
+//  获取命令行所在的目录
+function getRunCliPath({ directory = false, root = false } = {}) {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  if (root) {
+    return path.resolve(__dirname, "../");
+  }
+  return directory ? __dirname : __filename;
+}
+
+// 获取package.json
+function getPackageJson() {
+  const packageJson = JSON.parse(
+    fs.readFileSync(path.resolve(getRunCliPath({ root: true }), "../package.json"))
+  );
+  return packageJson;
+}
+// 判断是否存在该路径
+function isExistPath(path) {
+  return fs.existsSync(path);
+}
+
+// 写入缓存
+function writeCache(key, value) {
+  fs.writeFileSync(getRunCliPath({ root: true }) + "/.cache/" + key, value);
+}
+// 读取缓存
+function readCache(key) {
+  return fs.readFileSync(getRunCliPath({ root: true }) + "/.cache/" + key);
+}
+
+const sleep = (time) =>
+  new Promise((resolve = 2000) => {
+    setTimeout(() => resolve, time);
+  });
+async function upload$1() {
+  const SECRET_NAME = "sass";
+  const SECRET_NAME_PRO = "sass_pro";
+  let cacheSecret = {};
+  let cacheSecretPro = {};
+  if (!isExistPath(getRunCliPath({ root: true }) + "/.cache")) {
+    fs.mkdirSync(getRunCliPath({ root: true }) + "/.cache");
+  }
+  const cacheFilePath =
+    getRunCliPath({ root: true }) + "/.cache/" + SECRET_NAME;
+  const cacheFilePathPro =
+    getRunCliPath({ root: true }) + "/.cache/" + SECRET_NAME_PRO;
+  if (isExistPath(cacheFilePath)) {
+    cacheSecret = JSON.parse(readCache(SECRET_NAME));
+  }
+  if (isExistPath(cacheFilePathPro)) {
+    cacheSecretPro = JSON.parse(readCache(SECRET_NAME_PRO));
+  }
+  // 是否上传
+  inquirer
+    .prompt([
+      {
+        message: "是否上传到sass平台",
+        name: "upload",
+        type: "confirm",
+        default: true,
+      },
+      {
+        // 选择环境
+        message: "请选择环境",
+        name: "env",
+        type: "rawlist",
+        choices: [
+          {
+            name: "mit",
+            value: "mit",
+          },
+          {
+            name: "sit",
+            value: "sit",
+          },
+          {
+            name: "uat",
+            value: "uat",
+          },
+          {
+            name: "pro",
+            value: "pro",
+          },
+          //   {
+          //     name: "一键发布pro(mit->sit->uat->pro)",
+          //     value: "topro",
+          //   },
+          {
+            name: "一键发布uat(mit->sit->uat)",
+            value: "to-mit,sit,uat",
+          },
+          {
+            name: "一键发布sit(mit->sit)",
+            value: "to-mit,sit",
+          },
+        ],
+        when: function (res) {
+          return res.upload;
+        },
+        validate: function (val) {
+          if (val.length > 0) {
+            return true;
+          }
+          return "请选择环境";
+        },
+      },
+      {
+        message: "请输入域账号",
+        name: "username",
+        // 当upload为true时，展示
+        when: function (res) {
+          return res.upload && res.env !== "pro";
+        },
+        default: cacheSecret.username,
+        // 必填
+        validate: function (val) {
+          if (val) {
+            return true;
+          }
+          return "请输入域账号";
+        },
+      },
+      {
+        message: "请输入域密码",
+        name: "password",
+        default: cacheSecret.password,
+        when: function (res) {
+          return res.upload && res.env !== "pro";
+        },
+        // 必填
+        validate: function (val) {
+          if (val) {
+            return true;
+          }
+          return "请输入域密码";
+        },
+      },
+      {
+        message: "请输入生产域账号",
+        name: "username",
+        // 当upload为true时，展示
+        when: function (res) {
+          return res.upload && res.env === "pro";
+        },
+        default: cacheSecretPro.username,
+        // 必填
+        validate: function (val) {
+          if (val) {
+            return true;
+          }
+          return "请输入生产域账号";
+        },
+      },
+      {
+        message: "请输入生产域密码",
+        name: "password",
+        default: cacheSecretPro.password,
+        when: function (res) {
+          return res.upload && res.env === "pro";
+        },
+        // 必填
+        validate: function (val) {
+          if (val) {
+            return true;
+          }
+          return "请输入生产域密码";
+        },
+      },
+    ])
+    .then(async (res) => {
+      const { upload, env, username, password } = res;
+      let envList = [];
+      if (env.indexOf("to") > -1) {
+        envList = env.replace("to-", "").split(",");
+      } else {
+        envList = [env];
+      }
+      if (upload) {
+        writeCache(
+          env === "pro" ? "sass_pro" : "sass",
+          JSON.stringify({
+            username,
+            password,
+          })
+        );
+        // 上传逻辑
+        // 1.获取上传文件路径
+        const choices = fs
+          .readdirSync("./")
+          .filter((item) => item.indexOf(".xlsx") > -1);
+        //  2. 选择上传文件
+        inquirer
+          .prompt([
+            {
+              type: "rawlist",
+              name: "excelFileName",
+              message: "请选择要上传的excel文件",
+              choices,
+              validate: function (val) {
+                if (val) {
+                  return true;
+                }
+                return "请选择项目";
+              },
+            },
+          ])
+          .then(async (res) => {
+            const { excelFileName } = res;
+            // 2.读取excel
+            const uploadFilePath = "./" + excelFileName;
+            const projectList = await readExcel({ uploadFilePath });
+            for (const env of envList) {
+              // 1.登录
+              const token = await login({
+                env,
+                username,
+                password,
+              });
+              // 2.导入excel
+              await importExcel({
+                uploadFilePath,
+                token,
+                env,
+              });
+              sleep(2000);
+              // 3.上传
+              await uploadExcel({
+                data: {
+                  projectList,
+                },
+                token,
+                env,
+              });
+              console.log(`🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀${env}成功`);
+            }
+          });
+      }
+    });
+}
+
+// 获取应用list
+function getApplicationList({ appName, env, token }) {
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/api-u/api/saas/app/nameList`,
+        method: "POST",
+        json: true,
+        body: { name: appName, pageNo: 1, pageSize: 50 },
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+      },
+      function (error, response, body) {
+        const res = body;
+        if (!error && res.code == 200) {
+          resolve(
+            res.data.map((item) => {
+              //   return {
+              //     name: item.name,
+              //     value: item.id,
+              //   };
+              return {
+                name: item.name,
+                value: item.name,
+                id: item.id,
+                code: item.code,
+              };
+            })
+          );
+        } else {
+          console.log(chalk.red(error || JSON.stringify(res.data)));
+        }
+      }
+    );
+  });
+}
+// 获取应用按钮权限配置
+function getApplicationButtonConfig({ appId, env, token }) {
+  Loading$1.start(`获取按钮权限配置中...`);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/api-u/api/saas/permission/list`,
+        method: "POST",
+        json: true,
+        body: { id: appId },
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+      },
+      function (error, response, body) {
+        const res = body;
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`获取${env}环境按钮权限配置成功`);
+          resolve(res.data);
+        } else {
+          Loading$1.fail(`获取${env}环境按钮权限配置失败`);
+          console.log(chalk.red(error || JSON.stringify(res.data)));
+        }
+      }
+    );
+  });
+}
+// 删除应用按钮权限
+function deleteApplicationButtonConfig({ data, env, token }) {
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/api-u/api/saas/permission/del`,
+        method: "POST",
+        json: true,
+        body: data,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+      },
+      function (error, response, body) {
+        const res = body;
+        if (!error && res.code == 200) {
+          resolve(res.data);
+        } else {
+          const errorData = error || JSON.stringify(res.data);
+          console.log(chalk.red(errorData));
+          reject(errorData);
+        }
+      }
+    );
+  });
+}
+// 新增应用按钮权限
+function addApplicationButtonConfig({ data, env, token }) {
+  Loading$1.start(`新增按钮权限 ${data.code} 中...`);
+  return new Promise((resolve, reject) => {
+    request(
+      {
+        url: `https://${
+          env === "pro" ? "" : `${env}-`
+        }hxjf.hongxinshop.com/api-u/api/saas/permission/add`,
+        method: "POST",
+        json: true,
+        body: data,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "x-request-vaildate": "open",
+        },
+      },
+      function (error, response, body) {
+        const res = body;
+        if (!error && res.code == 200) {
+          Loading$1.succeed(`${data.code}`);
+          resolve(true);
+        } else {
+          Loading$1.fail(`${data.code}`);
+          console.log(chalk.red(error || JSON.stringify(res.data)));
+        }
+      }
+    );
+  });
+}
+async function syncSassConfig() {
+  inquirer
+    .prompt([
+      {
+        message: `使用须知:
+        ${chalk.green(`
+1.此命令会${chalk.red('强制覆盖')}[from]->[to]环境配置,${chalk.red('不会合并')}!!! \n 
+2.请确保同步前已经在目标环境创建了应用 \n 
+3.从mit->sit/uat,建议先同步sit->mit以保证mit环境的配置是最新的
+        `)}
+        `,
+        name: "notice",
+        type: "confirm",
+        default: false,
+      },
+      {
+        message: "请选择从哪个环境同步配置",
+        name: "from",
+        type: "list",
+        choices: ["mit", "sit", "uat"],
+        when: (answers) => answers.notice,
+      },
+      {
+        message: "请选择同步至哪个环境",
+        name: "to",
+        type: "list",
+        when: (answers) => answers.notice,
+        choices: (answers) => {
+          const list = ["mit", "sit", "uat"];
+          return list.filter((item) => item !== answers.from);
+        },
+      },
+    ])
+    .then(async (answers) => {
+      const { from, to,notice } = answers;
+      if(!notice){
+        return
+        }
+      const token = await login({
+        env: from,
+        username: "superAdmin",
+        password: "admin1",
+      });
+      const { inputAppName } = await inquirer.prompt([
+        {
+          message: "请输入应用名称关键字",
+          name: "inputAppName",
+          type: "input",
+          validate: function (value) {
+            if (value) {
+              return true;
+            }
+            return "请输入应用名称";
+          },
+        },
+      ]);
+      const applicationList = await getApplicationList({
+        env: from,
+        token,
+        appName: inputAppName,
+      });
+      const { appName } = await inquirer.prompt([
+        {
+          message: "请选择应用名称",
+          name: "appName",
+          type: "rawlist",
+          choices: applicationList,
+        },
+      ]);
+      const appId = applicationList.find((item) => item.name === appName).id;
+      //   let appConfig = await getApplicationConfig({ appId, env: from, token });
+      const fromButtonList = await getApplicationButtonConfig({
+        appId,
+        env: from,
+        token,
+      });
+      if (!fromButtonList.length) {
+        return console.log(chalk.red("按钮权限配置为空,无法同步"));
+      }
+      console.log(`开始同步到${to}🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀`);
+      const toToken = await login({
+        env: to,
+        username: "superAdmin",
+        password: "admin1",
+      });
+      const toApplicationList = await getApplicationList({
+        env: to,
+        token: toToken,
+        appName,
+      });
+      if (!toApplicationList.length) {
+        return console.log(chalk.red(`${to}环境不存在该应用`));
+      }
+      const toAppId = toApplicationList[0].id;
+      const toButtonList = await getApplicationButtonConfig({
+        appId: toAppId,
+        env: to,
+        token: toToken,
+      });
+      try {
+        if (toButtonList.length) {
+          const deleteButtonPromiseList = toButtonList.map((item) => {
+            return deleteApplicationButtonConfig({
+              data: {
+                id: item.id,
+                ver: item.ver,
+              },
+              env: to,
+              token: toToken,
+            });
+          });
+          Loading$1.start(`删除${to}环境按钮权限配置中...`);
+          await Promise.all(deleteButtonPromiseList);
+          Loading$1.succeed(`删除${to}环境按钮权限配置成功`);
+        }
+      } catch (error) {
+        console.log(chalk.red(`删除${to}环境按钮权限配置失败`));
+      } finally {
+        for (const item of fromButtonList) {
+          const { code, name, visitConf } = item;
+          await addApplicationButtonConfig({
+            env: to,
+            token: toToken,
+            data: {
+              code1: code.split(":")[0],
+              code,
+              name,
+              visitConf,
+              ascriptionApp: toAppId,
+            },
+          });
+        }
+        console.log(chalk.green("同步成功"));
+      }
+    });
+}
+
+/**
+ * @fileoverview 不要单独中文
+ * @author ypf
+ */
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+
+// 判断字符串是否是中文
+const isChinese = (str) => {
+  return /[\u4e00-\u9fa5]+/.test(str);
+};
+//去除特殊字符，包含空格
+function trimSpecial(string = "", formatter) {
+  // const pattern =
+  //   /[`~!@#$^\-&*()=|{}':;',\\\[\]\.<>\/?~！@#￥……&*（）——|{}【】'；：""'。，、？\s]/g;
+  // return string.replace(pattern, "");
+  // console.log(string);
+  // 获取开头空白符的位置
+  const startIdx = string.search(/\S/) - 1;
+  // 获取结尾空白符的位置
+  const endIdx = string.search(/\S\s*$/) + 1;
+  // 获取开头和结尾的字符串
+  const startStr = string.slice(0, startIdx + 1);
+  const endStr = string.slice(endIdx);
+  // 获取中间的字符串
+  const middle = string.slice(startIdx + 1, endIdx);
+  // 取出中间字符串的换行符
+  const middleStr = middle.replace(/\n/g, "");
+  return startStr + formatter(middleStr) + endStr;
+}
+// 判断当前节点是否已经翻译过
+function isTranslate(node) {
+  if (
+    node.parent?.parent?.parent?.type === "CallExpression" &&
+    node.parent?.parent?.parent?.callee?.name === "$hxt"
+  ) {
+    return true;
+  }
+  // console不翻译
+  if (
+    node.parent.type === "CallExpression" &&
+    node.parent.callee?.object?.name === "console"
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+// 空key
+const emptyKeyRules = (context) => {
+  return {
+    CallExpression(node) {
+      if (node.callee.name === "$hxt") {
+        const properties = node.arguments[0]?.properties || [];
+        // 如果属性是key且值为空
+        const result = properties.some((item) => {
+          // 去除key空格
+          const key = item.key.name.replace(/\s/g, "");
+          if (key === "key") {
+            // 去除value空格
+            // value是模版字符串
+            let value = "";
+            if (item.value.type === "TemplateLiteral") {
+              value = item.value.quasis[0].value.raw.replace(/\s/g, "");
+            } else if (item.value.type === "Literal") {
+              value = item.value.value.replace(/\s/g, "");
+            }
+            if (value === "") {
+              return true;
+            }
+          }
+        });
+        if (result) {
+          context.report({
+            node: node,
+            messageId: "noSingleChinese",
+            data: {
+              raw: chalk.green("key为空"),
+            },
+            fix: (fixer) => {},
+          });
+        }
+      }
+    },
+  };
+};
+var noSingleChineseRule = {
+  meta: {
+    type: "suggestion", // `problem`, `suggestion`, or `layout`
+    docs: {
+      description: "不要单独中文",
+      recommended: false,
+      url: null, // URL to the documentation page for this rule
+    },
+    fixable: "code", // Or `code` or `whitespace`
+    schema: [], // Add a schema if the rule has options
+    messages: {
+      noSingleChinese: "不要单独中文: {{raw}}",
+    }, // Add messageId and message
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    context.filename;
+    // console.log(filename,999999)
+    return context.parserServices.defineTemplateBodyVisitor(
+      // Event handlers for <template>.
+      {
+        // 纯字符串,如 测试
+        VText(node) {
+          // 如果是中文,替换为 {{ $hxt({key:'',desc:'中文'})}}
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                data: {
+                  raw: chalk.green(node.value),
+                },
+                // message: `VText`,
+                fix: (fixer) => {
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(node.value, (middle) => {
+                      return "{{ $hxt({key:'',desc:'" + middle + "'})}}";
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        // 纯字符串,如 {{ mini ? '测试' : `开启` }}中的测试
+        // 纯字符串,如 {{test('测试')}}中的测试
+        Literal(node) {
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                data: {
+                  raw: chalk.green(node.value),
+                },
+                // message: `Literal`,
+                fix: (fixer) => {
+                  // console.log(1111, node);
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(node.value, (middle) => {
+                      return "$hxt({key:'',desc:'" + middle + "'})";
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        // 模版字符串,
+        // 如{{ mini ? '测试' : `开启` }}中的开启
+        // 如{{ mini ? `${a}测试` : "开启" }}中的${a}测试
+        // 如{{`111`}}
+        // 如<p :a="`${a}册书`">
+        TemplateLiteral(node) {
+          if (!isTranslate(node)) {
+            const textSource = sourceCode.getText(node);
+            let text = textSource;
+            // 删除$符号
+            text = text.replace(/\${/g, "{");
+            if (isChinese(text)) {
+              // 获取expressions的文本
+              const expressionsText = node.expressions.map((item) => {
+                return sourceCode.getText(item);
+              });
+              let expressionStr = "";
+              if (expressionsText.length) {
+                expressionsText.forEach((item, index) => {
+                  const key = `slot${index + 1}`;
+                  text = text.replace(item, `${key}`);
+                  expressionStr += `${key}:${item},`;
+                });
+                // 删除最后一个逗号
+                expressionStr = `{${expressionStr.slice(0, -1)}}`;
+              }
+              if (!isChinese(text)) {
+                return;
+              }
+              context.report({
+                node,
+                data: {
+                  raw: chalk.green(textSource),
+                },
+                messageId: "noSingleChinese",
+                // message: `TemplateLiteral`,
+                fix: (fixer) => {
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(text, (middle) => {
+                      return `$hxt({key:'',desc:${middle}}${
+                        expressionStr ? `,${expressionStr}` : ""
+                      })`;
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        // 如<p title="1">
+        VLiteral(node) {
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                // message: `VLiteral`,
+                data: {
+                  raw: chalk.green(node.value),
+                },
+
+                fix: (fixer) => {
+                  // 父节点需要改为冒号方式
+                  const parentNode = node.parent;
+                  if (parentNode.type === "VAttribute") {
+                    const key = parentNode.key;
+                    return fixer.replaceText(
+                      parentNode,
+                      ":" +
+                        key.name +
+                        "=" +
+                        '"' +
+                        trimSpecial(node.value, (middle) => {
+                          return "$hxt({key:'',desc:'" + middle + "'})";
+                        }) +
+                        '"'
+                    );
+                  }
+                },
+              });
+            }
+          }
+        },
+        // 如 <p v-permission="测试">中的测试
+        Identifier(node) {
+          if (
+            !isTranslate(node) &&
+            node.parent.type === "VExpressionContainer"
+          ) {
+            if (isChinese(node.name)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                // message: `Identifier`,
+                data: {
+                  raw: chalk.green(node.name),
+                },
+                fix: (fixer) => {
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(node.name, (middle) => {
+                      return "$hxt({key:'',desc:'" + middle + "'})";
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        ...emptyKeyRules(context),
+      },
+      // Event handlers for <script> or scripts. (optional)
+      {
+        JSXText(node) {
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                data: {
+                  raw: chalk.green(node.value),
+                },
+                fix: (fixer) => {
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(node.value, (middle) => {
+                      return "{ $hxt({key:'',desc:'" + middle + "'})}";
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        TemplateLiteral(node) {
+          if (!isTranslate(node)) {
+            const textSource = sourceCode.getText(node);
+            let text = textSource;
+            // 删除$符号
+            text = text.replace(/\${/g, "{");
+            if (isChinese(text)) {
+              // 获取expressions的文本
+              const expressionsText = node.expressions.map((item) => {
+                return sourceCode.getText(item);
+              });
+              // console.log(expressionsText,111)
+              let expressionStr = "";
+              if (expressionsText.length) {
+                expressionsText.forEach((item, index) => {
+                  const key = `slot${index + 1}`;
+                  text = text.replace(item, `${key}`);
+                  expressionStr += `${key}:${item},`;
+                });
+                // 删除最后一个逗号
+                expressionStr = `{${expressionStr.slice(0, -1)}}`;
+              }
+              if (!isChinese(text)) {
+                return;
+              }
+              context.report({
+                node,
+                messageId: "noSingleChinese",
+                data: {
+                  raw: chalk.green(textSource),
+                },
+                // message: `TemplateLiteral`,
+                fix: (fixer) => {
+                  //  return console.log(text,expressionStr)
+                  // trimSpecial(text, (middle) => {
+                  //   return `$hxt({key:'',desc:${middle}}${
+                  //     expressionStr ? `,${expressionStr}` : ""
+                  //   })`;
+                  // })
+                  // return
+                  return fixer.replaceText(
+                    node,
+                    trimSpecial(text, (middle) => {
+                      return `$hxt({key:'',desc:${middle}}${
+                        expressionStr ? `,${expressionStr}` : ""
+                      })`;
+                    })
+                  );
+                },
+              });
+            }
+          }
+        },
+        Literal(node) {
+          // 如果正则忽略
+          if (node.regex) return;
+          if (!isTranslate(node)) {
+            if (isChinese(node.value)) {
+              // 增加{}包裹  render(){return <p title={'测试'} title="测试" title={`${1}测试`}>内容 {`测试`}</p>} 中的内容
+              if (node.parent.type === "JSXAttribute") {
+                context.report({
+                  node,
+                  messageId: "noSingleChinese",
+                  data: {
+                    raw: chalk.green(node.value),
+                  },
+                  fix: (fixer) => {
+                    return fixer.replaceText(
+                      node,
+                      trimSpecial(node.value, (middle) => {
+                        return "{$hxt({key:'',desc:'" + middle + "'})}";
+                      })
+                    );
+                  },
+                });
+              } else {
+                context.report({
+                  node,
+                  messageId: "noSingleChinese",
+                  data: {
+                    raw: chalk.green(node.value),
+                  },
+                  fix: (fixer) => {
+                    return fixer.replaceText(
+                      node,
+                      trimSpecial(node.value, (middle) => {
+                        return "$hxt({key:'',desc:'" + middle + "'})";
+                      })
+                    );
+                  },
+                });
+              }
+            }
+          }
+        },
+        ...emptyKeyRules(context),
+      }
+    );
+  },
+};
+
+/**
+ * @fileoverview 不能单独金额
+ * @author ypf
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+const inputTagNameList = [
+  "el-input",
+  "ElInput",
+  "hx-input",
+  "HxInput",
+  "van-field",
+  "VanField",
+  "hxmb-field",
+  "HxmbField",
+]; // input标签
+const formTagNameList = ["hx-form", "HxForm", "HxmForm", "hxmb-form"]; // form标签
+// 匹配金额名
+const currencyList = [
+  // "currency",
+  "total",
+  "price",
+  "amount",
+];
+// 价格后缀过滤
+const notIncludeCurrencySuffixList = [
+  "code",
+  "type",
+  "no",
+  "status",
+  "name",
+  "sort",
+  "source",
+  "qty",
+];
+// 关键字属性
+const keyPropList = ["prop", "name", "id", "key"];
+const hasCurrencyName = (str) => {
+  return currencyList.some((item) => {
+    str = str.toLowerCase();
+    const suffix = str.split(item)[1]?.toLowerCase();
+    if (str.includes(item)) {
+      if(suffix){
+        return !notIncludeCurrencySuffixList.some((item) =>
+          suffix.includes(item)
+        );
+      }
+      return true
+    }
+    return false;
+  });
+};
+var noSingleCurrencyRule = {
+  meta: {
+    type: "suggestion", // `problem`, `suggestion`, or `layout`
+    docs: {
+      description: "不能单独金额",
+      recommended: false,
+      url: null, // URL to the documentation page for this rule
+    },
+    fixable: null, // Or `code` or `whitespace`
+    schema: [], // Add a schema if the rule has options
+    messages: {
+      noSingleCurrency: "不要单独币种: {{raw}}",
+    }, // Add messageId and message
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    // 获取路径
+    const filename = context.filename;
+    return context.parserServices.defineTemplateBodyVisitor(
+      // Event handlers for <template>.
+      {
+        //  模版标签, 如<el-input >
+        VElement(node) {
+          const tagName = node.rawName;
+          if (inputTagNameList.indexOf(tagName) > -1) {
+            const attrs = node.startTag.attributes;
+            // 遍历找到v-model 属性
+            attrs.some((attr) => {
+              const attrTextSource = sourceCode.getText(attr);
+              if (attr.key?.name?.name === "model") {
+                const textSource = sourceCode.getText(attr.value);
+                // 如果包含currency、price、amount，则报错
+                if (hasCurrencyName(textSource)) {
+                  context.report({
+                    node,
+                    data: {
+                      raw:
+                        chalk.red(`Template|<${tagName}> `) +
+                        chalk.green(attrTextSource),
+                    },
+                    messageId: "noSingleCurrency",
+                    // message: `TemplateLiteral`,
+                    fix: (fixer) => {},
+                  });
+                }
+              }
+              return false;
+            });
+          }
+        },
+      },
+      // Event handlers for <script> or scripts. (optional)
+      {
+        // jsx 标签,如 render() { return <el-input /> } 中的<el-input />
+        //  <el-form formItemList=[]>中的formItemList
+        JSXElement(node) {
+          // console.log(node,'node')
+          const tagName = node?.openingElement?.name?.name;
+          // input
+          if (inputTagNameList.indexOf(tagName) > -1) {
+            // 遍历找到vModel 属性
+            const attrs = node.openingElement.attributes;
+            attrs.some((attr) => {
+              const attrTextSource = sourceCode.getText(attr);
+              // console.log(attrTextSource,'attrTextSource')
+              if (attr.name.name === "vModel") {
+                const textSource = sourceCode.getText(attr.value);
+                // 如果包含币种
+                if (hasCurrencyName(textSource)) {
+                  context.report({
+                    node,
+                    data: {
+                      raw:
+                        chalk.red(`JSX|<${tagName}> `) +
+                        chalk.green(attrTextSource),
+                    },
+                    messageId: "noSingleCurrency",
+                    // message: `TemplateLiteral`,
+                    fix: (fixer) => {},
+                  });
+                }
+              }
+            });
+          }
+          // form
+          if (formTagNameList.indexOf(tagName)) {
+            const attrs = node.openingElement.attributes;
+            // 遍历找到formItemList 属性
+            attrs.some((attr) => {
+              sourceCode.getText(attr);
+              // 是formItemList
+              if (attr?.name?.name === "formItemList") {
+                // 且值是数组
+                if (attr?.value?.expression?.type === "ArrayExpression") {
+                  // 遍历数组
+                  attr.value.expression.elements.forEach((item) => {
+                    (item.properties || []).some((item) => {
+                      const attrTextSource = sourceCode.getText(item);
+                      if (keyPropList.indexOf(item.key.name) > -1) {
+                        const textSource = sourceCode.getText(item.value);
+                        if (item?.value?.type === "CallExpression") return;
+                        // 如果包含币种
+                        if (hasCurrencyName(textSource)) {
+                          context.report({
+                            node,
+                            data: {
+                              raw:
+                                chalk.red(`JSX|${tagName}|${attr.name.name} `) +
+                                chalk.green(`${attrTextSource}`),
+                            },
+                            messageId: "noSingleCurrency",
+                            // message: `TemplateLiteral`,
+                            fix: (fixer) => {},
+                          });
+                        }
+                      }
+                    });
+                  });
+                }
+              }
+            });
+          }
+        },
+        // [{prop:'price'}]
+        ArrayExpression(node) {
+          // 不检测路由文件
+          if (filename.includes("src/router")) return;
+          // 是数组且不是jsx属性上的数组(上面已经检测过了,否则会出现2条错误)
+          if (node.parent?.parent?.type === "JSXAttribute") return;
+          (node.elements || []).forEach((item) => {
+            // 数组里面是对象
+            if (item?.type === "ObjectExpression") {
+              (item.properties || []).forEach((item) => {
+                const attrTextSource = sourceCode.getText(item);
+                if (keyPropList.indexOf(item?.key?.name) > -1) {
+                  if (item?.value?.type === "CallExpression") return;
+                  const textSource = sourceCode.getText(item.value);
+                  // 如果包含币种
+                  if (hasCurrencyName(textSource)) {
+                    context.report({
+                      node,
+                      data: {
+                        raw:
+                          chalk.red(`JSX|[{}] `) +
+                          chalk.green(`${attrTextSource}`),
+                      },
+                      messageId: "noSingleCurrency",
+                    });
+                  }
+                }
+              });
+            }
+          });
+        },
+      }
+    );
+  },
+};
+
+/**
+ * @fileoverview 不能单独金额
+ * @author ypf
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+const tagNameList = ["hx-search-list-page", "HxSearchListPage"];
+const attrNameList = ["custom-column-module", "customColumnModule"];
+const moduleArr = new Set();
+const getModuleArr = () => [...moduleArr];
+
+var noSingleCustomColumnModule = {
+  meta: {
+    type: "suggestion", // `problem`, `suggestion`, or `layout`
+    docs: {
+      description: "不能单独自定义列",
+      recommended: false,
+      url: null, // URL to the documentation page for this rule
+    },
+    fixable: null, // Or `code` or `whitespace`
+    schema: [], // Add a schema if the rule has options
+    messages: {}, // Add messageId and message
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    // 获取路径
+    const fullPathName = context.filename;
+    const cwd = context.cwd;
+    const getPath = (loc = {}) => {
+      const location = `${loc.start?.line}:${loc.start?.column} `;
+      return location + fullPathName.replace(cwd, "");
+    };
+    return context.parserServices.defineTemplateBodyVisitor(
+      // Event handlers for <template>.
+      {
+        //  模版标签,
+        VElement(node) {
+          const tagName = node.rawName;
+          if (tagNameList.indexOf(tagName) > -1) {
+            const attrs = node.startTag.attributes;
+            attrs.some((attr) => {
+              sourceCode.getText(attr);
+              if (
+                attrNameList.includes(attr.key?.argument?.rawName) &&
+                attr.value?.expression?.type === "Literal"
+              ) {
+                const value = attr.value.expression.value;
+                moduleArr.add({
+                  module: value,
+                  path: getPath(attr.loc),
+                });
+              } else if (
+                attrNameList.includes(attr.key?.rawName) &&
+                attr.value.type === "VLiteral"
+              ) {
+                const value = attr.value.value;
+                moduleArr.add({
+                  module: +value,
+                  path: getPath(attr.loc),
+                });
+              } else if (
+                attrNameList.includes(attr.key?.argument?.rawName) ||
+                attrNameList.includes(attr.key?.rawName)
+              ) {
+                moduleArr.add({
+                  module: sourceCode.getText(attr.value.expression),
+                  path: getPath(attr.loc),
+                  isDynamics: true, // 变量
+                });
+              }
+              return false;
+            });
+          }
+        },
+      },
+      // Event handlers for <script> or scripts. (optional)
+      {
+        JSXElement(node) {
+          const tagName = node?.openingElement?.name?.name;
+          if (tagNameList.indexOf(tagName) > -1) {
+            // 遍历找到customColumnModule 属性
+            const attrs = node.openingElement.attributes;
+            attrs.some((attr) => {
+              sourceCode.getText(attr);
+              if (attrNameList.includes(attr?.name?.name)) {
+                if (attr.value?.expression?.type === "Literal") {
+                  const value = attr.value.expression.value;
+                  moduleArr.add({
+                    module: value,
+                    path: getPath(attr.loc),
+                  });
+                } else {
+                  moduleArr.add({
+                    module: sourceCode.getText(attr.value.expression),
+                    path: getPath(attr.loc),
+                    isDynamics: true, // 变量
+                  });
+                }
+              }
+            });
+          }
+        },
+      }
+    );
+  },
+};
+
+/**
+ * @fileoverview 国际化
+ * @author ypf
+ */
+const require = createRequire(import.meta.url);
+const VueESlintParserPath = require.resolve('vue-eslint-parser');
+const meta = {
+  name: "eslint-plugin-i18n",
+  version: "1.0.0",
+};
+var i18n = {
+  rules: {
+    "no-single-chinese": noSingleChineseRule,
+    "no-single-currency": noSingleCurrencyRule,
+    "no-single-customColumnModule": noSingleCustomColumnModule,
+  },
+  processors: {},
+  configs: {
+    recommended: {
+      // 插件
+      plugins: [
+        "i18n", // 可以省略eslint-plugin-
+      ],
+      rules: {
+        "i18n/no-single-chinese": "warn",
+        "i18n/no-single-currency": "warn",
+        "i18n/no-single-customColumnModule": "warn",
+      },
+      // parser: "vue-eslint-parser",
+      parser: VueESlintParserPath, // 文档中是只能字符串
+      parserOptions: {
+        ecmaVersion: "latest", // 指定你想要使用的 ECMAScript 版本
+        sourceType: "module", // 支持脚本类型为模块,否则不支持import/export
+        ecmaFeatures: {
+          jsx: true,
+        },
+        parser: {
+          js: espree,
+          jsx: espree, // 支持jsx语法
+          // ts: tsParser,
+          // tsx: tsParser,
+        },
+      },
+    },
+  },
+};
+
+// https://www.npmjs.com/package/text-table?activeTab=readme
+
+function table (rows_, opts) {
+  if (!opts) opts = {};
+  var hsep = opts.hsep === undefined ? "  " : opts.hsep;
+  var align = opts.align || [];
+  var stringLength =
+    opts.stringLength ||
+    function (s) {
+      return String(s).length;
+    };
+  var dotsizes = reduce(
+    rows_,
+    function (acc, row) {
+      forEach(row, function (c, ix) {
+        var n = dotindex(c);
+        if (!acc[ix] || n > acc[ix]) acc[ix] = n;
+      });
+      return acc;
+    },
+    []
+  );
+
+  var rows = map(rows_, function (row) {
+    return map(row, function (c_, ix) {
+      var c = String(c_);
+      if (align[ix] === ".") {
+        var index = dotindex(c);
+        var size =
+          dotsizes[ix] + (/\./.test(c) ? 1 : 2) - (stringLength(c) - index);
+        return c + Array(size).join(" ");
+      } else return c;
+    });
+  });
+
+  var sizes = reduce(
+    rows,
+    function (acc, row) {
+      forEach(row, function (c, ix) {
+        var n = stringLength(c);
+        if (!acc[ix] || n > acc[ix]) acc[ix] = n;
+      });
+      return acc;
+    },
+    []
+  );
+
+  return map(rows, function (row) {
+    return map(row, function (c, ix) {
+      var n = sizes[ix] - stringLength(c) || 0;
+      var s = Array(Math.max(n + 1, 1)).join(" ");
+      if (align[ix] === "r" || align[ix] === ".") {
+        return s + c;
+      }
+      if (align[ix] === "c") {
+        return (
+          Array(Math.ceil(n / 2 + 1)).join(" ") +
+          c +
+          Array(Math.floor(n / 2 + 1)).join(" ")
+        );
+      }
+
+      return c + s;
+    })
+      .join(hsep)
+      .replace(/\s+$/, "");
+  }).join("\n");
+}
+
+function dotindex(c) {
+  var m = /\.[^.]*$/.exec(c);
+  return m ? m.index + 1 : c.length;
+}
+
+function reduce(xs, f, init) {
+  if (xs.reduce) return xs.reduce(f, init);
+  var i = 0;
+  var acc = arguments.length >= 3 ? init : xs[i++];
+  for (; i < xs.length; i++) {
+    f(acc, xs[i], i);
+  }
+  return acc;
+}
+
+function forEach(xs, f) {
+  if (xs.forEach) return xs.forEach(f);
+  for (var i = 0; i < xs.length; i++) {
+    f.call(xs, xs[i], i);
+  }
+}
+
+function map(xs, f) {
+  if (xs.map) return xs.map(f);
+  var res = [];
+  for (var i = 0; i < xs.length; i++) {
+    res.push(f.call(xs, xs[i], i));
+  }
+  return res;
+}
+
+//------------------------------------------------------------------------------
+
+/**
+ * Given a word and a count, append an s if count is not one.
+ * @param {string} word A word in its singular form.
+ * @param {int} count A number controlling whether word should be pluralized.
+ * @returns {string} The original word with an s on the end if count is not one.
+ */
+function pluralize(word, count) {
+    return (count === 1 ? word : `${word}s`);
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+function stylish(results) {
+
+    let output = "\n",
+        errorCount = 0,
+        warningCount = 0,
+        fixableErrorCount = 0,
+        fixableWarningCount = 0,
+        summaryColor = "yellow";
+    results.forEach(result => {
+        const messages = result.messages;
+
+        if (messages.length === 0) {
+            return;
+        }
+
+        errorCount += result.errorCount;
+        warningCount += result.warningCount;
+        fixableErrorCount += result.fixableErrorCount;
+        fixableWarningCount += result.fixableWarningCount;
+
+        output += `${chalk.underline(result.filePath)}\n`;
+
+        output += `${table(
+            messages.map(message => {
+                let messageType;
+
+                if (message.fatal || message.severity === 2) {
+                    messageType = chalk.red("error");
+                    summaryColor = "red";
+                } else {
+                    messageType = chalk.yellow("warning");
+                }
+
+                return [
+                    "",
+                    message.line || 0,
+                    message.column || 0,
+                    messageType,
+                    message.message.replace(/([^ ])\.$/u, "$1"),
+                    chalk.dim(message.ruleId || "")
+                ];
+            }),
+            {
+                align: ["", "r", "l"],
+                stringLength(str) {
+                    return stripAnsi(str).length;
+                }
+            }
+        ).split("\n").map(el => el.replace(/(\d+)\s+(\d+)/u, (m, p1, p2) => chalk.dim(`${p1}:${p2}`))).join("\n")}\n\n`;
+    });
+
+    const total = errorCount + warningCount;
+
+    if (total > 0) {
+        output += chalk[summaryColor].bold([
+            "\u2716 ", total, pluralize(" problem", total),
+            " (", errorCount, pluralize(" error", errorCount), ", ",
+            warningCount, pluralize(" warning", warningCount), ")\n"
+        ].join(""));
+
+        if (fixableErrorCount > 0 || fixableWarningCount > 0) {
+            output += chalk[summaryColor].bold([
+                "  ", fixableErrorCount, pluralize(" error", fixableErrorCount), " and ",
+                fixableWarningCount, pluralize(" warning", fixableWarningCount),
+                " potentially fixable with the `--fix` option.\n"
+            ].join(""));
+        }
+    }
+
+    // Resets output color, for prevent change on top level
+    return total > 0 ? chalk.reset(output) : "";
+}
+
+async function lint$1(patterns, fix, rule, hook = {}) {
+  const rules$1 = {
+    "i18n/no-single-chinese": rule ? "off" : "warn",
+  };
+  rules[0].choices.forEach((item) => {
+    rules$1[`i18n/no-single-${item.value}`] = "off";
+    if (item.children) {
+      item.children.forEach((child) => {
+        child.choices.forEach((item) => {
+          rules$1[`i18n/no-single-${item.value}`] = "off";
+        });
+      });
+    }
+  });
+  if (rule) {
+    rules$1[`i18n/no-single-${rule}`] = "warn";
+  }
+  const eslint = new ESLint({
+    useEslintrc: false, // 不检测其他规则,只检测i18n规则, 不设置为false,则会检测项目中的.eslintrc.js文件规则
+    // 只检测js,jsx,vue文件
+    extensions: [".js", ".jsx", ".vue"],
+    fix: fix || false, // 是否自动修复
+    overrideConfigFile: null,
+    plugins: { [meta.name]: i18n }, // 必须写,下面的extends才能识别, 和配置文件那种不一样,配置文件那种只写extends就行,不用写plugins
+    overrideConfig: {
+      extends: [
+        "plugin:i18n/recommended", // 表示使用test插件的推荐规则, plugin:后不能有空格,否则不生效
+      ],
+      // 此处增加rules是为了动态判断覆盖extends中的rule级别
+      rules: rules$1,
+    },
+  });
+  Loading$1.start(`检测中...`);
+  try {
+    // 检查文件
+    const results = await eslint.lintFiles(patterns);
+    hook.lintFilesAfter && (await hook.lintFilesAfter(results,Loading$1));
+    if (!fix) {
+      // 判断是否有匹配到错误
+      const hasErrors = results.some(
+        (result) => result.messages && result.messages.length
+      );
+      if (!hasErrors) {
+        return Loading$1.succeed(`没有要修复的错误`);
+      }
+      Loading$1.succeed(`检测完成`);
+      // 如果没有fix,则直接输出错误
+      return console.log(stylish(results));
+    }
+    // 判断是否有匹配到错误
+    const hasErrors1 = results.some(
+      (result) => result.output || result.warningCount
+    );
+    if (!hasErrors1) {
+      return Loading$1.succeed(`没有要修复的错误`);
+    }
+    // 输出回原文件
+    await ESLint.outputFixes(results);
+    Loading$1.succeed(`替换空key完成`);
+    inquirer
+      .prompt([
+        {
+          message: `是否开始翻译key`,
+          name: "isTransKey",
+          type: "confirm",
+          default: true,
+        },
+      ])
+      .then(({ isTransKey }) => {
+        if (isTransKey) {
+          console.log(chalk.green(`开始准备翻译...`));
+          process$1.execSync(`fe-it-alpha --fix -i ${patterns} `, {
+            stdio: "inherit", // 打印子进程的输出到父进程
+          });
+        }
+      });
+  } catch (error) {
+    Loading$1.fail(`检测失败`);
+    console.error(chalk.red(error));
+  }
+}
+
+const condition = {
+  currency: hasCurrencyName,
+};
+async function customColumnModule (lintc, fix, rule, parentRule) {
+  const { way } = await inquirer.prompt([
+    {
+      message: "请选择检测自定义列方式",
+      name: "way",
+      type: "list",
+      choices: [
+        {
+          name: "自动检测HxSearchListPage的自定义列ID",
+          value: "normal",
+        },
+        {
+          name: "自定义输入",
+          value: "input",
+        },
+      ],
+    },
+  ]);
+  if (way === "normal") {
+    lint$1(lintc, fix, "customColumnModule", {
+      lintFilesAfter: (results, Loading) => {
+        const arr = getModuleArr();
+        const dynamicsArr = arr.filter((item) => item.isDynamics);
+        const normalArr = arr.filter((item) => !item.isDynamics);
+
+        return new Promise((resolve) => {
+          Loading.succeed(`检测完成,${arr.length?'':'未'}匹配到规则`);
+          if (arr.length) {
+            getColumn(normalArr, dynamicsArr, parentRule);
+          }
+        });
+      },
+    });
+  } else if (way === "input") {
+    const { customColumnId } = await inquirer.prompt([
+      {
+        message: "请输入自定义列ID,格式为xx,xx,xx",
+        name: "customColumnId",
+        type: "input",
+      },
+    ]);
+    const moduleArr = customColumnId.split(",").map((item) => {
+      return {
+        module: item,
+        path: "NA",
+      };
+    });
+    getColumn(moduleArr, [], parentRule);
+  }
+}
+
+async function getColumn(moduleArr = [], dynamicsArr = [],parentRule) {
+  const token = await login({
+    env: "sit",
+    username: "superAdmin",
+    password: "admin1",
+  });
+  const requestArr = moduleArr.map(({ module, path }) =>
+    request$1({
+      url: `http://sit-hxjf.hongxinshop.com/api-item/api/customizedColumns/find`,
+      method: "POST",
+      json: true,
+      body: { module },
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "x-request-vaildate": "open",
+      },
+    })
+  );
+  Promise.allSettled(requestArr).then(async (res) => {
+    const tableData = [];
+    res.forEach(({ value, status }, index) => {
+      const { path, module } = moduleArr[index];
+      if (status === "fulfilled") {
+        const { data } = value;
+        const { showColumns, hiddenColumns } = data;
+        let fieldArr = [];
+        showColumns.concat(hiddenColumns).forEach((item) => {
+          if (condition[parentRule](item.showField)) {
+            fieldArr.push(`${item.showField} ${item.showName}`);
+          }
+        });
+        if (fieldArr.length) {
+          fieldArr.forEach((item, index) => {
+            let obj = {
+              module,
+              field: item,
+              path,
+            };
+            if (index !== 0) {
+              // obj.module = module;
+              // obj.path = path;
+              delete obj.module;
+              delete obj.path;
+            }
+            tableData.push(obj);
+          });
+        } else {
+          tableData.push({
+            module,
+            field: "NA",
+            path,
+          });
+        }
+      } else {
+        tableData.push({
+          module,
+          field: "error",
+          path,
+        });
+      }
+    });
+    // 合并动态模块
+    dynamicsArr.forEach((item) => {
+      tableData.push({
+        module: item.module,
+        field: "error",
+        path: item.path,
+      });
+    });
+    // 排序, field为NA和error的排在后面
+    tableData.sort((a, b) => {
+      if (["NA", "error"].includes(b.field)) {
+        return -1;
+      } else {
+        return 1;
+      }
+    });
+    const successTableData = []; // 成功的数据
+    const naTableData = [];
+    const noNaTableData = [];
+    const errorTableData = []; // 失败的数据
+    tableData.forEach((item) => {
+      if (item.field === "error") {
+        errorTableData.push(item);
+      } else {
+        if (item.field === "NA") {
+          naTableData.push(item);
+        } else {
+          noNaTableData.push(item);
+        }
+        successTableData.push(item);
+      }
+    });
+
+    console.log(
+      chalk.green(
+        `共${tableData.length}个moduleId, 成功${
+          successTableData.length
+        }个(规则命中${noNaTableData.length}个, ${chalk.yellow(
+          `未命中${naTableData.length}个`
+        )}),`
+      ) + chalk.red(`失败${errorTableData.length}个`)
+    );
+    if (noNaTableData.length) {
+      console.log(chalk.green(`成功命中规则`));
+      console.table(noNaTableData);
+    }
+    if (errorTableData.length) {
+      console.log(chalk.red(`失败,需手动处理或重试`));
+      console.table(errorTableData);
+    }
+    if (naTableData.length) {
+      console.log(chalk.yellow(`成功但未命中规则,无需处理`));
+      console.table(naTableData);
+    }
+  });
+}
+
+// import packageJson from "../package.json" assert { type: "json" };
+const { version } = getPackageJson();
+// const spinner = ora();
+program.version(version);
+program.option("-i, --input <type>", "翻译空key");
+// command('merge')
+// .option("-i, --input <type>" , "翻译空key")
+// .option("-m, --merge" , "输出文件").action((options) => {
+//   console.log('merge', options)
+// })
+// 上传翻译
+program.option("-u, --upload", "上传翻译包");
+// 同步sass应用权限配置
+program.option("-sass, --sass", "同步sass按钮权限配置");
+// 检测未$hxt中文
+program.option("-lint, --lint <patterns>", "检测未$hxt的中文");
+// 检测配置项
+program.option("-lintc, --lintc <patterns>", "检测指定配置规则");
+// 检测未$hxt中文自动修复
+program.option("--fix", "修复lint检出的错误");
+program.parse(process.argv);
+
+// 判断命令参数
+const { input, sass, upload, lint, lintc, fix } = program.opts();
+const rules = [
+  {
+    message: "请选择检查规则",
+    name: "rule",
+    type: "list",
+    choices: [
+      {
+        name: "币种",
+        value: "currency",
+        children: [
+          {
+            message: "请选择场景",
+            name: "scene",
+            type: "list",
+            choices: [
+              {
+                name: "匹配属性名含有price、total、amount金额字段",
+                value: "currency",
+              },
+              {
+                name: "自定义列",
+                value: "customColumnModule",
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+];
+if (sass) {
+  syncSassConfig();
+} else if (upload) {
+  upload$1();
+} else if (lint) {
+  lint$1(lint, fix);
+} else if (lintc) {
+  inquirer.prompt(rules).then(async ({ rule }) => {
+    const parentRule =rule;
+    if (rule === "currency") {
+      const ruleChoice = rules.find((item) => item.name === "rule");
+      const currencySubChoice = ruleChoice.choices.find(
+        (item) => item.value === "currency"
+      ).children;
+      const { scene } = await inquirer.prompt(currencySubChoice);
+      rule = scene;
+      if(rule==='customColumnModule'){
+        return customColumnModule(lintc,fix,rule,parentRule)
+      }
+    }
+    lint$1(lintc, fix, rule);
+  });
+} else {
+  let projectName = "请在package.json中配置name字段(项目名称)";
+  const projectPath = "./package.json";
+  const isExist = isExistPath(projectPath);
+  if (isExist) {
+    const str = fs.readFileSync(projectPath, "utf-8").toString();
+    projectName = JSON.parse(str).name;
+  }
+  inquirer
+    .prompt([
+      {
+        message: `请确认package.json中项目名称是否是${projectName}`,
+        name: "isProjectName",
+        type: "confirm",
+        default: true,
+      },
+    ])
+    .then((res) => {
+      if (res.isProjectName) {
+        inquirer
+          .prompt([
+            {
+              message: "请选择翻译接口",
+              name: "type",
+              type: "list",
+              choices: [
+                {
+                  name: "百度翻译",
+                  value: "baidu",
+                },
+              ],
+            },
+          ])
+          .then((res) => {
+            const { type } = res;
+            let cacheSecret = {};
+            if (!isExistPath(getRunCliPath({ root: true }) + "/.cache")) {
+              fs.mkdirSync(getRunCliPath({ root: true }) + "/.cache");
+            }
+            const cacheFilePath =
+              getRunCliPath({ root: true }) + "/.cache/" + res.type;
+            if (isExistPath(cacheFilePath)) {
+              const cache = JSON.parse(readCache(res.type));
+              cacheSecret = cache;
+            }
+            const question = [
+              {
+                message: "请输入百度翻译的appid",
+                name: "appid",
+                default: cacheSecret.appid,
+                // 必填
+                validate: function (val) {
+                  if (val) {
+                    return true;
+                  }
+                  return "请输入百度翻译的appid";
+                },
+              },
+              {
+                message: "请输入百度翻译的key",
+                name: "key",
+                default: cacheSecret.key,
+                // 必填
+                validate: function (val) {
+                  if (val) {
+                    return true;
+                  }
+                  return "请输入百度翻译的key";
+                },
+              },
+            ];
+            inquirer.prompt(question).then((res) => {
+              writeCache(
+                type,
+                JSON.stringify({
+                  type,
+                  ...res,
+                })
+              );
+              const { appid, key } = res;
+              const isLintFix = fix;
+              translateUtil(appid, key, projectName, isLintFix);
+            });
+          });
+      } else {
+        console.log(
+          chalk.red("请在package.json中配置正确的name字段(项目名称)")
+        );
+      }
+    });
+}
+
+function translateUtil(appid, key, projectName, isLintFix) {
+  const { input } = program.opts();
+  let src = [input];
+  const isSrcDirectory = fs.statSync(input).isDirectory();
+  if (isSrcDirectory) {
+    const directory = input + "/**/*.{js,vue,jsx,ts,tsx}";
+    src = glob.sync(directory, {
+      ignore: directory + `/**/node_modules/**`,
+    });
+  }
+  let allArr = []; // 所有文本组成的数组
+  let groupArr = []; // 分组后的数组
+  let newAllArr = []; // 分组后的数组还原成所有数组
+  // 循环遍历文件下的文件
+  function readFolder(isOk) {
+    // spinner.start();
+    src.forEach((item, index) => {
+      const fPath = item;
+      let file = fs.readFileSync(fPath, "utf-8").toString();
+      // 提取file里所有以$hxt({ key: '', desc:为开头 以')}结尾的字符串
+      const reg =
+        /\$hxt\([\r\n\s]*\{[\r\n\s]*key[\r\n\s]*:[\r\n\s]*['|"][\r\n\s]*['|"],[\r\n\s]*desc[\r\n\s]*:[\r\n\s]*['|"|`](.*?)['|"|`],*[\r\n\s]*\}(\)|,[\r\n\s]*\{)/g;
+      file = file.replace(reg, function (match, p1, p2) {
+        if (isOk) {
+          const reg1 = /key[\r\n\s]*:[\r\n\s]*('|")[\r\n\s]*('|")/g;
+          let key = newAllArr.find(
+            (item) => item.path === fPath && item.ZH_CN === p1
+          ).key;
+          // 去除{ slotxx }
+          key = key.replace(/\{[\r\n\s]*slot\d[\r\n\s]*\}/g, "");
+          // 去除空格
+          key = key.replace(/\s/g, "");
+          return match.replace(reg1, `key: '${key}'`);
+        } else {
+          allArr.push({
+            path: fPath,
+            ZH_CN: p1,
+            EN: "",
+            key: "",
+          });
+        }
+      });
+      if (isOk) {
+        fs.writeFileSync(fPath, file, "utf-8");
+      }
+    });
+    if (isOk) {
+      // spinner.stop();
+      return;
+    }
+    // 数组分割,如果str长度大于2000，就分割成多个数组
+    let str = "";
+    let cutArr = [];
+    console.log(chalk.green(`共有${allArr.length}条数据需要翻译`));
+    allArr.forEach((item, index) => {
+      if (str.length > 2000) {
+        groupArr.push(cutArr);
+        str = "";
+        cutArr = [];
+      }
+      str += item.ZH_CN + "\n";
+      cutArr.push(item);
+    });
+    if (cutArr.length > 0) {
+      Array.prototype.push.apply(groupArr, [cutArr]);
+    } else {
+      groupArr = allArr;
+    }
+    console.log(chalk.green(`共有${groupArr.length}组数据需要翻译`));
+    if(!groupArr.length) return
+    const task = groupArr.map(async (item, index) => {
+      let str = "";
+      item.forEach((item1, index1) => {
+        // 去除换行空格
+        const ZH_CN = item1.ZH_CN.replace(/\n/g, "");
+        str += ZH_CN + "\n";
+      });
+      return translate(item, str, index + 1);
+    });
+    Promise.allSettled(task).then(async (res) => {
+      console.log(chalk.green("任务执行完毕"));
+      groupArr.forEach((item, index) => {
+        Array.prototype.push.apply(newAllArr, item);
+      });
+      readFolder(true);
+
+      let exportData = [];
+      // key中有debug排后面
+      const sortNewAllArr = _.sortBy(newAllArr, function (item) {
+        return item.key.indexOf("debug") > -1;
+      });
+      sortNewAllArr.forEach((item, index) => {
+        const rowArr = [
+          "GIT", // 系统
+          projectName, // 项目
+          "frontInit", // 模块（路由）
+          "", // 编码
+          1, // 所属(1：前端 2：后端)
+          1, // 数据类型(1:static,2:enum,3:json)
+          "", // 中文值
+          "", // 英文
+          "", // 泰文(TH)
+          "", // 越南(VI)
+          "", // 土耳其(TR)
+        ];
+        const cacheIndex = {
+          ZH_CN: 6,
+          EN: 7,
+          key: 3,
+        };
+        Object.entries(item).forEach(([key, value], index1) => {
+          const insertIndex = cacheIndex[key];
+          rowArr[insertIndex] = value;
+        });
+        exportData.push(rowArr);
+      });
+      const { isMerge } = await inquirer.prompt([
+        {
+          message: `是否合并至export.xlsx,默认${chalk.red("否,直接覆盖")}`,
+          name: "isMerge",
+          type: "confirm",
+          default: false,
+        },
+      ]);
+      try {
+        if (isMerge) {
+          const str = xlsx.parse(fs.readFileSync("./export.xlsx"));
+          if (str[0].data.length) {
+            exportData = str[0].data.concat(exportData);
+          } else {
+            throw new Error();
+          }
+        } else {
+          throw new Error();
+        }
+      } catch (error) {
+        // 第一行插入标题
+        exportData.unshift([
+          "系统",
+          "项目",
+          "模块",
+          "编码",
+          "所属(1：前端 2：后端)",
+          "数据类型(1:static,2:enum,3:json)",
+          "中文值",
+          "英文",
+          "泰文(TH)",
+          "越南(VI)",
+          "土耳其(TR)",
+        ]);
+      }
+      const buffer = xlsx.build([{ data: exportData }]);
+      fs.writeFileSync(`./export.xlsx`, buffer, "binary");
+      console.log(chalk.green(`${isMerge?"合并":"覆盖"}文件成功`));
+    });
+  }
+
+  // 百度翻译接口
+  async function translate(item, str, groupIndex) {
+    const q = str;
+    const salt = Math.random();
+    const from = "zh";
+    const to = "en";
+    const sign = md5(appid + q + salt + key);
+    const query = querystring.stringify({
+      q,
+      appid,
+      salt,
+      from,
+      to,
+      sign,
+    });
+    const url = "http://api.fanyi.baidu.com/api/trans/vip/translate?" + query;
+    return new Promise((resolve, reject) => {
+      // 自动翻译延时，必须大于 1000 ms，否则调用百度翻译 API 会失败
+      throttle(() => {
+        console.log(chalk.green(`正在翻译第${groupIndex}组数据`));
+        return request(url, function (_error, response, body) {
+          const resBody = JSON.parse(body);
+          if (resBody.trans_result) {
+            console.log(`ok`);
+            let result = resBody.trans_result || [];
+            item.forEach((item1, index1) => {
+              const id = v5(item1.path, v5.URL).slice(0, 6);
+              if (result[index1] && result[index1].src === item1.ZH_CN) {
+                // 删除str中的单引号或双引号或斜杠或逗号
+                let str = result[index1].dst
+                  .replace(/\'/g, "")
+                  .replace(/\"/g, "")
+                  .replace(/\//g, "")
+                  .replace(/\,/g, "");
+                // 每个单词首首字母转换为大写
+                const s = str.split(" ");
+                let key = s
+                  .map((item, index) => {
+                    return item[0].toUpperCase() + item.slice(1);
+                  })
+                  .join("");
+                // 去除key中的标点符号
+                key = key.replace(/[^a-zA-Z0-9{}]/g, "").slice(0, 73);
+                let EN = result[index1].dst;
+                EN = EN[0].toUpperCase() + EN.slice(1);
+                item1.EN = EN;
+                if (isLintFix) {
+                  item1.key = nanoid().replace("_", "a");
+                  // item1.key = id + "-" + key;
+                } else {
+                  item1.key = id + "-" + key;
+                }
+              }
+            });
+            resolve(true);
+          } else {
+            item.forEach((item1, index1) => {
+              const id = v5(item1.path, v5.URL).slice(0, 6);
+              item1.key = id + "-" + "debug";
+            });
+            console.log(chalk.red(`error: ${body}`));
+            resolve(true);
+          }
+        });
+      });
+    });
+  }
+  // md5加密
+  function md5(str) {
+    const md5 = crypto.createHash("md5");
+    md5.update(str);
+    return md5.digest("hex");
+  }
+
+  // 节流函数
+  const delay = 2000;
+  const throttle = (function (delay = 1500) {
+    const wait = [];
+    let canCall = true;
+    return function throttle(callback) {
+      if (!canCall) {
+        if (callback) wait.push(callback);
+        return;
+      }
+
+      callback();
+      canCall = false;
+      setTimeout(() => {
+        canCall = true;
+        if (wait.length) {
+          throttle(wait.shift());
+        }
+      }, delay);
+    };
+  })(delay);
+  // 开始方法
+  readFolder();
+}
+
+export { rules };