@zzclub/z-cli 0.7.1 → 1.0.0

package/src/command/tiny.js

@@ -1,328 +0,0 @@
-import {
-  writeFileContent,
-  getLocalConfig,
-  setHighLightStr,
-} from "../utils/common.js";
-
-import { getFormatedFileSize, replaceFileContent } from "../utils/file.js";
-import chalk from "chalk";
-import ora from "ora";
-import path from "node:path";
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import fs from "node:fs";
-import sharp from "sharp";
-import { picgoCmd } from "./picgo.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const supportFileTypes = ["png", "jpg", "jpeg", "gif", "webp"];
-
-export const tinyCmd = {
-  name: "tiny",
-  description: "压缩图片",
-  options: [
-    {
-      flags: "-t, --type <fileType>",
-      description: "转换后的图片类型",
-      defaultValue: null,
-    },
-    {
-      flags: "-f, --file <file>",
-      description: "要压缩的图片文件",
-      defaultValue: null,
-    },
-    {
-      flags: "-d, --dir <dir>",
-      description: "压缩文件夹内所有文件",
-      defaultValue: null,
-    },
-    {
-      flags: "-co, --condition <condition>",
-      description: "压缩文件夹内所有名称包含[--condition]的图片文件",
-      defaultValue: null,
-    },
-    {
-      flags: "-q, --quality <quality>",
-      description: "压缩质量(1-100)",
-      defaultValue: 75,
-    },
-    {
-      flags: "-c, --colours <colours>",
-      description: "GIF色彩保留(2-256)",
-      defaultValue: 128,
-    },
-    {
-      flags: "-n, --name <name>",
-      description: "指定文件名输出",
-      defaultValue: "",
-    },
-    {
-      flags: "-m, --max <max>",
-      description: "限制要上传的文件大小(仅当开启 --picgo 时会用到)",
-      defaultValue: 60,
-    },
-    {
-      flags: "--picgo [type]",
-      description: "是否调用picgo",
-      defaultValue: null,
-    },
-    {
-      flags: "--no-picgo [type]",
-      description: "是否调用picgo",
-      defaultValue: null,
-    },
-    {
-      flags: "-ref, --replace-file <replaceFile>",
-      description: "要替换内容的文件",
-      defaultValue: "",
-    },
-    {
-      flags: "--no-replace [type]",
-      description:
-        "是否替换指定文件的内容, 替换规则斤仅针对Obsidian, 请看readme.md",
-      defaultValue: null,
-    },
-    {
-      flags: "--replace [type]",
-      description:
-        "是否替换指定文件的内容, 替换规则斤仅针对Obsidian, 请看readme.md",
-      defaultValue: null,
-    },
-  ],
-  action: async (option) => {
-    let spinner = ora();
-    let config = await getLocalConfig();
-    // console.log(`OPTION`, option);
-    let { type, file, dir, condition, quality, colours } = option;
-
-    if (!file && !dir && !condition) {
-      spinner.fail("请指定要压缩的文件(--file=xxx)或文件夹(--dir=/a/b)");
-      process.exit(1);
-    }
-
-    // 是否需要替换内容, true时 需要收集list<Map>
-    let isNeedUploadAndReplace = !!(
-      //   option.picgo &&
-      (option.replace && option.replaceFile)
-    );
-    let replaceMaps = [];
-
-    function collectReplaceMaps(replaceMaps, { text, newText }) {
-      if (isNeedUploadAndReplace) {
-        let map = {
-          text, // obsidian md 文件中 粘贴后的 值
-          newText, // 此时是压缩后的文件名, 在picgo里再替换成上传后的
-        };
-        replaceMaps.push(map);
-      }
-    }
-    async function tinyFile(file, statisticsCount, options = {}) {
-      try {
-        let stats = fs.statSync(file);
-        let isFile = stats.isFile();
-        if (isFile) {
-          // 文件类型
-          let extname = path.extname(file);
-          // 带后缀的文件名
-          let fileName = path.basename(file)?.split(".")[0];
-          // 文件路径
-          let dirPath = path.dirname(file);
-          // 文件类型
-          let filetype = extname.slice(1);
-          let fileSize = stats.size;
-          let beforeSize = getFormatedFileSize(fileSize);
-          // 是否在支持的格式里
-          // 如果正在批量压缩, 并且要求指定名称输出, 则加一个index后缀, 避免重名
-          let customFileName;
-          if (options.count && options.count > 1 && option.name) {
-            customFileName = `${option.name}${options.order + 1}`;
-          } else {
-            customFileName = option.name || `${fileName}-tiny`;
-          }
-
-          let outputPath =
-            path.resolve(process.cwd(), dirPath) +
-            "/" +
-            customFileName +
-            extname;
-          let inputPath = path.resolve(process.cwd(), file);
-          if (extname.slice(1) === "gif") {
-            //   console.log(`option.colours`, option.colours);
-            await sharp(inputPath, {
-              animated: true,
-              limitInputPixels: false,
-            })
-              .gif({
-                colours: +option.colours,
-              })
-              .toFile(outputPath);
-            let afterStats = fs.statSync(outputPath);
-            let afterSize = getFormatedFileSize(afterStats.size);
-            let offPercent = ((1 - afterStats.size / fileSize) * 100).toFixed(
-              2
-            );
-            spinner.succeed(
-              `${chalk.red(beforeSize)} ${chalk.yellowBright(
-                "=>"
-              )} ${chalk.green(afterSize)} (${
-                offPercent >= 0 ? chalk.green("↓") : chalk.red("↑")
-              }${Math.abs(offPercent)}%)【 ${customFileName}${extname} 】`
-            );
-            // 收集压缩前后的文件名映射关系
-            collectReplaceMaps(replaceMaps, {
-              text: `${path.basename(file)}`,
-              newText: `${customFileName}${extname}`,
-            });
-            statisticsCount.ok++;
-            statisticsCount.okFiles.push(outputPath);
-          } else {
-            if (sharp(inputPath)[filetype]) {
-              await sharp(path.resolve(process.cwd(), file))
-                [filetype]({ quality: +quality })
-                .toFile(outputPath);
-              let afterStats = fs.statSync(outputPath);
-              let afterSize = getFormatedFileSize(afterStats.size);
-              let offPercent = ((1 - afterStats.size / fileSize) * 100).toFixed(
-                2
-              );
-              spinner.succeed(
-                `${chalk.red(beforeSize)} ${chalk.yellowBright(
-                  "=>"
-                )} ${chalk.green(afterSize)} (${
-                  offPercent >= 0 ? chalk.green("↓") : chalk.red("↑")
-                }${Math.abs(offPercent)}%)【 ${customFileName}${extname} 】`
-              );
-              // 收集压缩前后的文件名映射关系
-              collectReplaceMaps(replaceMaps, {
-                text: `${path.basename(file)}`,
-                newText: `${customFileName}${extname}`,
-              });
-              statisticsCount.ok++;
-              statisticsCount.okFiles.push(outputPath);
-            } else {
-              spinner.fail(
-                `不支持此文件类型[${filetype || fileName || file}]!`
-              );
-              statisticsCount.error++;
-              statisticsCount.okFiles.push(outputPath);
-            }
-          }
-        }
-      } catch (err) {
-        // console.log(`err`, err);
-        spinner.fail("出错啦, 文件不存在或不支持此类型 \n" + err);
-        statisticsCount.error++;
-        statisticsCount.errFiles.push(outputPath);
-      }
-    }
-
-    let statisticsCount = {
-      ok: 0,
-      okFiles: [],
-      err: 0,
-      errFiles: [],
-    };
-    // 指定了文件, 压缩
-    if (file) {
-      await tinyFile(file, statisticsCount);
-    }
-
-    // 指定文件夹, 翻译文件夹内所有文件
-    if (dir || condition) {
-      let inputDirPath = dir || "./";
-      let files;
-      try {
-        // 读取所有文件
-        files = fs.readdirSync(inputDirPath);
-        // spinner.succeed(`共有${files.length}个文件`);
-      } catch (err) {
-        spinner.fail("出错啦, 文件夹似乎不存在");
-        process.exit(1);
-      }
-
-      for (let i = 0; i < files.length; i++) {
-        let file = files[i];
-        let filePath = path.join(inputDirPath, file);
-        let stats = fs.statSync(filePath);
-        if (stats.isFile()) {
-          if (condition) {
-            let fileName = path.basename(file);
-            let index = fileName.indexOf(condition);
-            if (index > -1) {
-              let tip = setHighLightStr(fileName, condition);
-              spinner.succeed(`${tip}正在压缩`);
-              await tinyFile(filePath, statisticsCount, {
-                count: files.length,
-                order: i,
-              });
-            }
-          } else {
-            spinner.succeed(`正在压缩:${file}`);
-            await tinyFile(filePath, statisticsCount, {
-              count: files.length,
-              order: i,
-            });
-          }
-        } else {
-          spinner.fail(`${filePath}不是文件`);
-        }
-      }
-      spinner.succeed(`压缩成功 ${chalk.green(statisticsCount.ok)} 个`);
-    }
-
-    // 自动替换wiki链接
-    // 因为obsidian里已经有了一个插件, 可以自动上传到picgo并替换链接, 功能重复度很高
-    // 后续考虑给作者提个pr, 加入压缩功能
-    // console.log(`fileMaps`, replaceMaps);
-    if (option.replace) {
-      // 上传成功改的图片文件
-      let tinyFiles = statisticsCount.okFiles;
-      if (tinyFiles && tinyFiles.length) {
-        // await batchUploadByPicGo(tinyFiles, option);
-        if (!option.replace) process.exit(1);
-        spinner.start("开始替换文件内容, 替换后请仔细检查!");
-        console.log(`replaceMaps`, replaceMaps);
-        const fileContent = await replaceFileContent(
-          option.replaceFile,
-          replaceMaps
-        );
-        console.log(`fileContent`, fileContent);
-        if (!fileContent) {
-          spinner.fail("替换文件内容失败! 请检查要替换的文件是否存在!");
-          process.exit(1);
-        }
-        try {
-          fs.writeFileSync(option.replaceFile, fileContent, "utf-8");
-          spinner.succeed(
-            `[${chalk.red(
-              path.basename(option.replaceFile)
-            )}]图片链接替换完成!请前往检查!`
-          );
-        } catch (err) {
-          spinner.fail("图片链接替换失败!");
-        }
-      }
-      // 处理完后不再上传picgo
-      process.exit(1);
-    }
-    // 自动上传至picgo
-    if (option.picgo) {
-      spinner.start(`正在连接picgo`);
-      await picgoCmd.action({
-        tinyFiles: statisticsCount.okFiles,
-        max: option.max,
-        replace: isNeedUploadAndReplace,
-        replaceFile: option.replaceFile,
-        replaceMaps,
-      });
-      spinner.stop();
-
-      // 只有开启了picgo后时 才会使用替换功能 后续替换功能会独立出去 目前仅为满足自己所需
-      //   if (option.replace && option.replaceFile) {
-      //     spinner.start(`开始替换内容, 替换后请仔细检查!`);
-      //   }
-    }
-  },
-};

package/src/command/translate.js

@@ -1,337 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import chalk from "chalk";
-import { translate } from "../translate-api/index.js";
-import { readJsonFile } from "../utils/file.js";
-import { writeFileContent, getLocalConfig } from "../utils/common.js";
-import ora from "ora";
-
-const translateCmd = {
-  name: "translate",
-  alias: "trans",
-  description: "中译英功能,支持批量和单个文件翻译",
-  // options: ['-l, --language <language>', '转换为什么语言, 支持[zh]和[en]', 'en'],
-  options: [
-    {
-      flags: "-l, --language <language>",
-      description: "目前只支持从中文到英文",
-      defaultValue: "en",
-    },
-    {
-      flags: "-f, --file <file>",
-      description: "转换文件的路径",
-      defaultValue: null,
-    },
-    {
-      flags: "-d, --dir <dirpath>",
-      description: "转换文件夹的路径",
-      defaultValue: null,
-    },
-  ],
-  action: async (option) => {
-    let filePath = option.file;
-    let dirPath = option.dir;
-    let file_spinner = ora();
-    if (!filePath && !dirPath) {
-      file_spinner.fail('请指定文件或目录')
-      process.exit(1);
-    }
-    
-    let config = await getLocalConfig();
-    const translateConfig = config.translate;
-    if (!translateConfig.account.appId || !translateConfig.account.key) {
-      file_spinner.fail("请先设置appId和key后再使用翻译功能");
-      process.exit(1);
-    }
-    // 有文件夹路径时忽略文件
-    if (dirPath) {
-      dirPath = path.resolve(process.cwd(), dirPath);
-      let stat;
-      try {
-        stat = fs.statSync(dirPath);
-      } catch (err) {
-        file_spinner.fail(`${chalk.red(dirPath)}不存在!`);
-        return;
-      }
-
-      if (!stat.isDirectory()) {
-        file_spinner.fail(`${chalk.red(dirPath)}不是一个文件夹!`);
-        return;
-      } else {
-        let filePaths = [];
-        file_spinner.succeed(`开始检索${chalk.red(dirPath)}`);
-
-        getAllFilePaths(translateConfig, dirPath, filePaths);
-
-        // log.success(`共找到${chalk.red(filePaths.length)}个要翻译的文件`);
-        if (filePaths.length) {
-          file_spinner.succeed(
-            `共找到${chalk.red(filePaths.length)}个要翻译的文件`
-          );
-          file_spinner.start();
-          await execWorkerSync(filePaths, 0);
-          file_spinner.stop();
-        } else {
-          //   log.success(`Exit`);
-          file_spinner.warn(
-            `共找到${chalk.red(filePaths.length)}个要翻译的文件`
-          );
-        }
-      }
-    } else {
-      file_spinner.succeed(`正在翻译${chalk.yellowBright(filePath)}`);
-      file_spinner.start();
-      let file_content = await readAndTranslateFileContent(filePath);
-      let fileName = path.basename(filePath);
-      let dirPath = path.dirname(filePath);
-      let newFileName =
-        fileName.split(".")[0] +
-        `-${option.language}.` +
-        fileName.split(".")[1];
-      let newFilePath = dirPath + "/" + newFileName;
-      writeFileContent(newFilePath, file_content, (spinner, isOk) => {
-        if (isOk) {
-          spinner.succeed("翻译结束");
-        } else {
-          spinner.fail("翻译失败!");
-        }
-
-        file_spinner.stop();
-      });
-    }
-  },
-};
-
-/**
- * 递归处理i18n配置对象
- * @param config i18n配置js 一般为langs文件下的js文件
- * @description 把js对象处理成 [ { keys: ['common', 'title'], value: '要翻译的值'} ]  每个要翻译的中文为一个item keys表示他在对象里的位置
- */
-function parseConfigs(config) {
-  let words = [];
-
-  parseConfig(config, null);
-  function parseConfig(config, curItem) {
-    let keys = Object.keys(config);
-    keys.forEach((key) => {
-      let item = {
-        keys: curItem ? curItem.keys.concat([key]) : [key],
-        value: config[key],
-      };
-      // 对象的value为string时则为要翻译的值
-      if (typeof item.value === "string") {
-        words.push(item);
-      } else {
-        parseConfig(item.value, item);
-      }
-    });
-  }
-  return words;
-}
-
-/**
- * 把所有要翻译的词分组 每秒有查询次数限制
- * @param words 处理好的数据
- * @param limitLength 每秒查几个词
- * @returns {*[]} 处理后的二维数组
- */
-function limitWords(words, limitLength = 7) {
-  let wordsLimit = [];
-  if (words.length < limitLength) {
-    return [words];
-  } else {
-    for (let i = 0; i < words.length; i += limitLength) {
-      wordsLimit.push(words.slice(i, i + limitLength));
-    }
-    return wordsLimit;
-  }
-}
-
-/**
- * 调用翻译功能
- * @param limitedWords 分组后的word数据
- * @param cb 全部翻译结束后的回调函数
- */
-function startTranslate(limitedWords, cb) {
-  let curIndex = 0;
-  let timer = null;
-  timer = setInterval(() => {
-    if (curIndex >= limitedWords.length) {
-      clearInterval(timer);
-      cb && cb();
-    } else {
-      limitedWords[curIndex].forEach(async (word) => {
-        let res = await translate({
-          query: word.value,
-          from: "zh",
-          to: "en",
-        }).catch((err) => {
-          console.log(err);
-        });
-
-        let translate_result = res?.trans_result
-          ? res?.trans_result[0].dst
-          : word.value;
-        if (res?.error_code || !res) {
-          const spinner = ora();
-          spinner.warn(`翻译[${word.value}]时出错：` + JSON.stringify(res))
-        }
-        word.value = translate_result;
-      });
-      curIndex++;
-    }
-  }, 1000);
-}
-
-/**
- * 组装翻译后的数据结构
- * @param words
- * @param obj
- */
-function setTranslatedObj(words, obj) {
-  words.forEach((item) => {
-    item.keys.forEach((key, index) => {
-      if (index === 0 && item.keys.length > 1) {
-        if (!obj[key]) obj[key] = {};
-      } else if (index < item.keys.length - 1) {
-        // a.b.c
-        let _key = item.keys.slice(0, index + 1).join(".");
-        let flag = false;
-        eval(`flag = !!!obj.${_key}`);
-        if (flag) eval(`obj.${_key} = {}`);
-      } else {
-        let _key = item.keys.slice(0, index + 1).join(".");
-        eval(`obj.${_key} = "${item.value}"`);
-      }
-    });
-  });
-}
-function unquoteKeys(json) {
-  return json.replace(/"(\\[^]|[^\\"])*"\s*:?/g, function (match) {
-    if (/:$/.test(match)) {
-      return match.replace(/^"|"(?=\s*:$)/g, "");
-    } else {
-      return match;
-    }
-  });
-}
-/**
- * 读取并翻译文本内容
- * @param filePath 文件地址
- * @param cb 翻译后的回调
- * @return 翻译后的文本
- */
-function readAndTranslateFileContent(filePath, cb = () => {}) {
-  return new Promise((resolve, reject) => {
-    fs.readFile(filePath, { encoding: "utf8" }, (err, data) => {
-      if (err) {
-        // log.error("读取文件失败");
-        reject();
-      } else {
-        let jsonObj;
-        let fileData = data.toString();
-        let startIndex = fileData.indexOf("{");
-        let endIndex = fileData.lastIndexOf("}");
-        let jsonStr = fileData.slice(
-          startIndex,
-          endIndex === fileData.length ? endIndex : endIndex + 1
-        );
-        try {
-          // 当成js执行
-          eval("jsonObj = " + jsonStr);
-        } catch (err) {
-          jsonObj = null;
-          //   log.error("文件解析失败");
-          reject();
-        }
-
-        if (jsonObj) {
-          let obj = {};
-          let words = parseConfigs(jsonObj);
-          let limitedWords = limitWords(words, 7);
-          //   log.on(`正在翻译${chalk.yellow(filePath)}`);
-          startTranslate(limitedWords, () => {
-            let words_result = limitedWords.flat(1);
-            setTranslatedObj(words_result, obj);
-            let file_result =
-              `export default ` + unquoteKeys(JSON.stringify(obj, null, 2));
-            resolve(file_result);
-          });
-        }
-      }
-    });
-  });
-}
-
-/**
- * 获取所有需要处理的文件路径+目标路径
- * @param dirPath 从指定的目录地址开始查找
- * @param filePaths 一个空数组，用来接收结果
- */
-function getAllFilePaths(translateConfig, dirPath, filePaths) {
-  let files = fs.readdirSync(dirPath);
-  files.forEach((file) => {
-    let filePath = path.join(dirPath, file);
-    let stats = fs.statSync(filePath);
-    // 是否是文件夹
-    let isDir = stats.isDirectory();
-    if (isDir) {
-      if (file === translateConfig.sourceDirName) {
-        // 找到目标文件夹, 获取所有文件
-        let files = fs.readdirSync(filePath);
-        files.forEach((file) => {
-          let jsPath = path.join(filePath, file);
-          let targetPath = path.join(dirPath, translateConfig.targetDirName);
-          filePaths.push({
-            sourcePath: jsPath,
-            targetPath,
-          });
-        });
-      } else if (!translateConfig.ignoreFiles.includes(file)) {
-        getAllFilePaths(translateConfig, filePath, filePaths);
-      }
-    }
-  });
-}
-
-/**
- * 同步执行所有翻译操作
- * 因为每秒请求数有限制, 异步请求会超过最大并发数
- * @param files 所有要翻译的文件
- * @param index 当前进行到的index
- */
-async function execWorkerSync(files, index = 0) {
-  let fileItem = files[index];
-  let file_content = await readAndTranslateFileContent(fileItem.sourcePath);
-  let fileName = path.basename(fileItem.sourcePath);
-  let newFilePath = fileItem.targetPath + "/" + fileName;
-  let exist = fs.existsSync(fileItem.targetPath);
-  // 自动创建不存在的目录
-  if (!exist) {
-    try {
-      //   log.on(`创建文件夹${chalk.yellow(fileItem.targetPath)}`);
-      fs.mkdirSync(fileItem.targetPath);
-    } catch (error) {
-      //   log.error(`创建文件夹${chalk.red(fileItem.targetPath)}失败`);
-      process.exit(1);
-    }
-  }
-  writeFileContent(newFilePath, file_content, async (spinner, isOk) => {
-    if (isOk) {
-      spinner.succeed(`${newFilePath}已翻译`);
-    } else {
-      spinner.fail(`${newFilePath}翻译失败`);
-    }
-    index++;
-    if (index < files.length) {
-      spinner.start();
-      await execWorkerSync(files, index);
-      spinner.stop();
-    } else {
-      spinner.stop();
-      spinner.succeed("翻译完毕");
-    }
-  });
-}
-
-export { translateCmd };

package/src/config.json

@@ -1,16 +0,0 @@
-{
-  "translate": {
-    "sourceDirName": "zh-CN",
-    "targetDirName": "en-US",
-    "ignoreFiles": [
-      "node_modules"
-    ],
-    "account": {
-      "appId": "",
-      "key": ""
-    }
-  },
-  "editableConfig": [
-    "translate"
-  ]
-}

package/src/index.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { registerCommand, initProgram } from "./command/index.js";
-import { translateCmd } from "./command/translate.js";
-import { configCmd } from "./command/config.js";
-import { setCmd } from "./command/set.js";
-import { tinyCmd } from "./command/tiny.js";
-import { picgoCmd } from "./command/picgo.js";
-import { checkUpdate, checkNodeVersion } from './utils/common.js'
-import { i18nCmd } from "./command/i18n.js";
-
-const program = new Command();
-
-initProgram(program, async () => {
-
-  if (process.env.RUNTIME_ENV !== 'electron') {
-    checkNodeVersion()
-    await checkUpdate()
-  }
-
-  registerCommand(program, translateCmd);
-
-  registerCommand(program, setCmd);
-
-  registerCommand(program, configCmd);
-
-  registerCommand(program, tinyCmd);
-  registerCommand(program, picgoCmd);
-  registerCommand(program, i18nCmd)
-  program.parse(process.argv);
-});