slidev-addon-sm/bin/mksubtoc.mjs

slidev-addon slidev sm

#!/usr/bin/env node

import { link } from "fs";
import { $, cd, fs, path } from "zx";

const customSort = (a, b) => {
  if (a.includes("-") && b.includes("-")) {
    const numA = parseInt(a.match(/\d+/)[0], 10);
    const numB = parseInt(b.match(/\d+/)[0], 10);
    return numA - numB;
  }
  if (a.includes("-")) return true;
  else if (b.includes("-")) return false;

  //都没有 -
  return a.localeCompare(b) > 0 ? true : false;
};

const appendString = (filePath, str) => {
  fs.appendFileSync(filePath, str);
};

const appendBlankLine = (filePath) => {
  appendString(filePath, "\n");
};

const appendPageLine = (filePath) => {
  appendBlankLine(filePath);
  appendString(filePath, "---\n");
  appendString(filePath, "layout: SmLogoTRLayout\n");
  appendString(filePath, "---\n");
  appendBlankLine(filePath);
};

const baseName = (name) => {
  let t = name.split("-");
  if (t.length > 1) return t[1];
  return name;
};

const endLayout = (filePath) => {
  appendBlankLine(filePath);
  appendString(filePath, "---\n");
  appendString(filePath, "layout: sm-end\n");
  appendString(filePath, "---\n");
  appendBlankLine(filePath);
};

const autoCreateOrder = (dir) => {
  let orderFilePath = dir + "/order.txt";
  let subFiles = fs.readdirSync(dir).filter((t) => path.extname(t) === ".md");

  subFiles.sort(customSort);
  subFiles.forEach((subFile) => {
    let subFileName = subFile.toString();

    if (subFileName === "README.md") return;
    else if (subFileName.toString().includes("_publish.md")) return;

    let names = subFileName.split("-");
    let torderFileName = names[0];
    if (names.length > 1) {
      torderFileName = names[1];
    }
    torderFileName = torderFileName.replace(".md", "");

    appendString(orderFilePath, torderFileName + "\n");
  });
};

const PAGE_DIR = "./pages";

try {
  //检索pages下的md文件，并以序号排序
  let subDirs = fs.readdirSync(PAGE_DIR);
  subDirs.sort(customSort);

  subDirs.forEach((subDir) => {
    //目前只测试list目录
    // if (
    //   !subDir.toString().includes("list") &&
    //   !subDir.toString().includes("vector") &&
    //   !subDir.toString().includes("queue") &&
    //   !subDir.toString().includes("priority_queue") &&
    //   !subDir.toString().includes("stack") &&
    //   !subDir.toString().includes("map")&&
    //   !subDir.toString().includes("set")
    // )
    //   return;

    let subDirPath = PAGE_DIR + "/" + subDir;
    fs.readdirSync(subDirPath).filter((t) => {
      if (t.toString().includes("_publish.md")) {
        fs.unlinkSync(subDirPath + "/" + t);
      }
    });

    let subFiles = fs
      .readdirSync(subDirPath)
      .filter((t) => path.extname(t) === ".md");

    let readmeFilePath = subDirPath + "/README.md";
    if (fs.existsSync(readmeFilePath)) {
      fs.unlinkSync(readmeFilePath);
    }

    let orderFilePath = subDirPath + "/order.txt";
    if (!fs.existsSync(orderFilePath)) {
      // 新建的文件夹，自动生成order.txt
      autoCreateOrder(subDirPath);
    }

    let id = 1;
    let subId = 0;
    let orderFlag = false;
    let passFlag = false;
    let idUsedFlag = false;
    subFiles.forEach((subFile) => {
      let subFileName = subFile.toString();
      if (subFileName === "README.md") return;

      let subFileBaseName = baseName(subFileName);
      subFileBaseName = subFileBaseName.replace(".md", "");
      let newSubFileBaseName = subFileName;
      let publishFileName = subFileName.replace(".md", "") + "_publish.md";
      orderFlag = false;
      passFlag = false;
      subId = 0;

      if (fs.existsSync(orderFilePath)) {
        let cnt = 1;
        let orderData = fs.readFileSync(orderFilePath);
        orderData
          .toString()
          .split("\n")
          .forEach((data) => {
            let dataStr = data.toString();
            if (dataStr.trim().length <= 0) return;
            if (dataStr[0] == "#" || dataStr[0] == "/") return;
            if (orderFlag) return;

            dataStr = dataStr.trim();
            let tArray = dataStr.split(" ");
            if (tArray.length > 1) {
              dataStr = tArray[0];
            }
            if (dataStr.trim().localeCompare(subFileBaseName) == 0) {
              orderFlag = true;
              if (tArray[1] == "0") {
                //隐藏 的文件
                passFlag = true;
              }
              return;
            }
            cnt++;
          });
        if (passFlag) return;
        if (orderFlag) id = cnt;
        newSubFileBaseName = id + "." + subId + "-" + subFileBaseName;
        subId++;
        idUsedFlag = true;
        publishFileName = newSubFileBaseName + "_publish.md";
        newSubFileBaseName += ".md";
      }

      let newSubFilePath = subDirPath + "/" + newSubFileBaseName;
      if (subFileName != newSubFileBaseName) {
        fs.renameSync(subDirPath + "/" + subFileName, newSubFilePath);
      }

      let publishFilePath = subDirPath + "/" + publishFileName;
      if (fs.existsSync(publishFilePath)) {
        fs.unlinkSync(publishFilePath);
      }
      fs.copyFileSync(newSubFilePath, publishFilePath);
      appendBlankLine(publishFilePath);
      appendBlankLine(publishFilePath);

      let exampleId = 1;
      let cppFiles = fs
        .readdirSync(subDirPath)
        .filter(
          (t) =>
            t.toString().includes(".cpp") &&
            t.toString().includes(subFileBaseName)
        );
      cppFiles.sort(customSort);
      cppFiles.forEach((cppFile) => {
        let cppFileBaseName = baseName(cppFile.toString());
        if (
          cppFileBaseName.length < subFileBaseName.length ||
          cppFileBaseName.substring(0, subFileBaseName.length) !=
            subFileBaseName
        ) {
          return;
        }

        let newCppFileName = cppFileBaseName;
        if (idUsedFlag) {
          newCppFileName = id + "." + subId + "-" + cppFileBaseName;
          subId++;
        }
        let newCppFilePath = subDirPath + "/" + newCppFileName;
        if (newCppFileName != cppFile.toString()) {
          fs.renameSync(subDirPath + "/" + cppFile, newCppFilePath);
        }

        cppFileBaseName = cppFileBaseName.replace(".cpp", "");
        let tExampleId = cppFileBaseName.replace(subFileBaseName, "");
        if (tExampleId.length <= 0) {
          tExampleId = exampleId;
          exampleId++;
        }

        appendBlankLine(publishFilePath);
        appendPageLine(publishFilePath);
        appendString(
          publishFilePath,
          "### " + subFileBaseName + " 实例 " + tExampleId
        );
        appendBlankLine(publishFilePath);
        appendBlankLine(publishFilePath);

        let data = fs.readFileSync(newCppFilePath);
        appendString(publishFilePath, "```cpp");
        let dataArray = data.toString().split("\n");
        let aimLines = "";
        let lineId = 0;
        dataArray.forEach((line) => {
          lineId++;
          if (line.includes(subFileBaseName)) {
            if (aimLines.trim().length > 0) aimLines += "|";
            aimLines += lineId;
          }
        });
        if (aimLines.length > 0) {
          appendString(publishFilePath, " {" + aimLines + "|all}");
        } else {
          appendString(publishFilePath, " {all}");
        }
        if (lineId > 22) {
          appendString(publishFilePath, "{maxHeight:'400px'}");
        }
        appendBlankLine(publishFilePath);
        appendString(publishFilePath, data.toString());
        appendBlankLine(publishFilePath);
        appendString(publishFilePath, "```");

        appendBlankLine(publishFilePath);
        appendBlankLine(publishFilePath);
      });
      if (idUsedFlag) {
        id++;
        idUsedFlag = false;
      }
    });

    let subTitle = subDir;
    if (subDir.includes("-")) {
      subTitle = subDir.split("-")[1];
    }

    appendString(readmeFilePath, "---\n");
    appendString(readmeFilePath, "layout: SmLogoTRLayout\n");
    appendString(readmeFilePath, "---\n");
    appendBlankLine(readmeFilePath);
    appendString(readmeFilePath, "# " + subTitle);
    appendBlankLine(readmeFilePath);
    appendBlankLine(readmeFilePath);
    appendString(readmeFilePath, '<Toc maxDepth="2" minDepth="2"/>');
    appendBlankLine(readmeFilePath);
    appendBlankLine(readmeFilePath);

    let publishFiles = fs
      .readdirSync(subDirPath)
      .filter((f) => f.includes("_publish.md"));
    publishFiles.sort(customSort);
    publishFiles.forEach((publishFile) => {
      appendBlankLine(readmeFilePath);
      appendString(readmeFilePath, "---\n");
      appendString(readmeFilePath, "src: ./" + publishFile + "\n");
      appendString(readmeFilePath, "---\n");
      appendBlankLine(readmeFilePath);
    });

    endLayout(readmeFilePath);
  });
} catch (err) {
  console.error(err);
}