markdown-cache 1.0.0

package/.editorconfig

@@ -0,0 +1,4 @@
+[*]
+indent_style = space
+indent_size = 2
+insert_final_newline = true

package/.prettierignore

@@ -0,0 +1,6 @@
+node_modules/**
+package.json
+package-lock.json
+.cache/**
+**/*.min.js
+**/*.min.css

package/.prettierrc

@@ -0,0 +1,23 @@
+{
+  "tabWidth": 2,
+  "useTabs": false,
+  "printWidth": 80,
+  "semi": true,
+  "endOfLine": "lf",
+  "singleQuote": false,
+  "arrowParens": "always",
+  "overrides": [
+    {
+      "files": "src/index.html",
+      "options": {
+        "printWidth": 10000
+      }
+    },
+    {
+      "files": "api_src/anitxt/*.json",
+      "options": {
+        "printWidth": 1
+      }
+    }
+  ]
+}

package/.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["EditorConfig.EditorConfig", "esbenp.prettier-vscode"]
+}

package/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+  "explorer.fileNesting.enabled": true,
+  "explorer.fileNesting.patterns": {
+    "package.json": "package-lock.json, pnpm*, .yarnrc*, yarn*, .eslint*, eslint*, .oxlint*, oxlint*, .prettier*, prettier*, .editorconfig"
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll": "explicit"
+  },
+  "editor.formatOnSave": true,
+  "editor.defaultFormatter": "esbenp.prettier-vscode"
+}

package/README.md

@@ -0,0 +1 @@
+# md-cache

package/index.js

@@ -0,0 +1,5 @@
+import MarkdownCache from "./md-cache";
+
+export default MarkdownCache;
+
+export { MarkdownCache };

package/md-cache.js

@@ -0,0 +1,145 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import crypto from "node:crypto";
+import fm from "front-matter";
+
+export default class MarkdownCache {
+  constructor(options = {}) {
+    if (!options.md) {
+      throw new Error("No markdown-it provide!");
+    }
+
+    this.md = options.md;
+    this.fmParser = fm;
+
+    this.root = options.root || process.cwd();
+    this.mdRoot = options.mdRoot || "markdown";
+
+    this.markdownDir = path.join(this.root, this.mdRoot);
+
+    this.cacheDir = path.join(this.root, ".cache");
+    this.htmlCacheDir = path.join(this.cacheDir, "md_html");
+    this.fmCacheDir = path.join(this.cacheDir, "md_fm");
+
+    this.metadataPath = path.join(this.cacheDir, "md_cache.json");
+
+    this._initPromise = null;
+  }
+
+  async _init() {
+    await fs.mkdir(this.htmlCacheDir, { recursive: true });
+    await fs.mkdir(this.fmCacheDir, { recursive: true });
+
+    try {
+      await fs.access(this.metadataPath);
+    } catch {
+      await fs.writeFile(this.metadataPath, "{}", "utf-8");
+    }
+  }
+
+  async _ensureInit() {
+    if (!this._initPromise) {
+      this._initPromise = () => this._init();
+    }
+    await this._initPromise();
+  }
+
+  _getHash(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+
+  _getCacheKey(requestPath) {
+    return this._getHash(requestPath);
+  }
+
+  async _readMetadata() {
+    const data = await fs.readFile(this.metadataPath, "utf-8");
+    return JSON.parse(data || "{}");
+  }
+
+  async _writeMetadata(metadata) {
+    await fs.writeFile(this.metadataPath, JSON.stringify(metadata), "utf-8");
+  }
+
+  async _readMarkdown(requestPath) {
+    const fullPath = path.join(this.markdownDir, requestPath);
+    return fs.readFile(fullPath, "utf-8");
+  }
+
+  _getFrontmatter(attributes) {
+    return Object.assign(
+      { author: "xyxjs", license: "CC BY-NC-SA 4.0" },
+      attributes,
+    );
+  }
+
+  async _build(requestPath) {
+    await this._ensureInit();
+
+    let rawContent;
+    try {
+      rawContent = await this._readMarkdown(requestPath);
+    } catch {
+      return null;
+    }
+
+    const parsed = this.fmParser(rawContent);
+
+    const fmJson = this._getFrontmatter(parsed.attributes);
+    const mdBody = parsed.body + "\n[TOC]\n";
+
+    const contentHash = this._getHash(rawContent);
+    const cacheKey = this._getCacheKey(requestPath);
+
+    const metadata = await this._readMetadata();
+    const record = metadata[requestPath];
+
+    const htmlPath = path.join(this.htmlCacheDir, `${cacheKey}.html`);
+    const jsonPath = path.join(this.fmCacheDir, `${cacheKey}.json`);
+
+    if (record && record.hash === contentHash) {
+      try {
+        const [html, json] = await Promise.all([
+          fs.readFile(htmlPath, "utf-8"),
+          fs.readFile(jsonPath, "utf-8"),
+        ]);
+
+        return {
+          html,
+          fm: JSON.parse(json),
+        };
+      } catch {}
+    }
+
+    const html = this.md.render(mdBody);
+
+    await Promise.all([
+      fs.writeFile(htmlPath, html, "utf-8"),
+      fs.writeFile(jsonPath, JSON.stringify(fmJson), "utf-8"),
+    ]);
+
+    metadata[requestPath] = {
+      hash: contentHash,
+      cacheFileName: cacheKey,
+      updatedAt: Date.now(),
+    };
+
+    await this._writeMetadata(metadata);
+
+    return {
+      html,
+      fm: fmJson,
+    };
+  }
+
+  async html(requestPath) {
+    const result = await this._build(requestPath);
+    return result ? result.html : "Markdown file not found.";
+  }
+
+  async fm(requestPath) {
+    const result = await this._build(requestPath);
+    return result ? result.fm : {};
+  }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "markdown-cache",
+  "author": "xyxjs",
+  "description": "Provide markdown with markdown-it & cache",
+  "keywords": [
+    "markdown",
+    "markdown-it",
+    "cache",
+    "express"
+  ],
+  "license": "MIT",
+  "version": "1.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/xyxjs/md-cache.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xyxjs/md-cache/issues"
+  },
+  "main": "index.js",
+  "type": "module",
+  "dependencies": {
+    "front-matter": "^4.0.2"
+  }
+}