boltdocs 1.0.4 → 1.3.0

package/dist/node/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,23 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/node/index.ts
-var node_exports = {};
-__export(node_exports, {
-  default: () => boltdocs,
-  generateStaticPages: () => generateStaticPages
-});
-module.exports = __toCommonJS(node_exports);
-
-// src/node/plugin/index.ts
-var import_vite = require("vite");
-
-// src/node/routes/index.ts
-var import_fast_glob = __toESM(require("fast-glob"));
-
 // src/node/utils.ts
-var import_fs = __toESM(require("fs"));
-var import_gray_matter = __toESM(require("gray-matter"));
 function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
@@ -89,82 +76,363 @@ function fileToRoutePath(relativePath) {
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+var import_fs, import_gray_matter;
+var init_utils = __esm({
+  "src/node/utils.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    import_gray_matter = __toESM(require("gray-matter"));
+  }
+});
 
 // src/node/cache.ts
-var FileCache = class {
-  entries = /* @__PURE__ */ new Map();
-  /**
-   * Retrieves parsed data for a file from the cache.
-   * Compares the current filesystem mtime with the cached mtime.
-   *
-   * @param filePath - The absolute path of the file
-   * @returns The cached data if valid, or `null` if the file has changed or doesn't exist
-   */
-  get(filePath) {
-    const entry = this.entries.get(filePath);
-    if (!entry) return null;
-    const currentMtime = getFileMtime(filePath);
-    if (currentMtime !== entry.mtime) return null;
-    return entry.data;
-  }
-  /**
-   * Stores parsed data for a file in the cache, recording its current mtime.
-   *
-   * @param filePath - The absolute path to the file
-   * @param data - The parsed data to store
-   */
-  set(filePath, data) {
-    this.entries.set(filePath, {
-      data,
-      mtime: getFileMtime(filePath)
-    });
-  }
-  /**
-   * Checks if a specific file's cache is still valid (based on its mtime).
-   *
-   * @param filePath - The absolute path to the file
-   * @returns `true` if the cache is valid, `false` otherwise
-   */
-  isValid(filePath) {
-    return this.get(filePath) !== null;
-  }
-  /**
-   * Manually removes a specific file from the cache.
-   * Useful when forcefully invalidating a single updated file.
-   *
-   * @param filePath - The absolute path to the file
-   */
-  invalidate(filePath) {
-    this.entries.delete(filePath);
-  }
-  /**
-   * Clears the entire cache, forcing all files to be re-parsed on the next request.
-   * Useful when global dependencies (like config) change.
-   */
-  invalidateAll() {
-    this.entries.clear();
-  }
-  /**
-   * Removes cached entries for files that no longer exist on the filesystem.
-   * Prevents memory leaks from deleted files.
-   *
-   * @param currentFiles - A Set of absolute file paths currently discovered on the disk
-   */
-  pruneStale(currentFiles) {
-    for (const key of this.entries.keys()) {
-      if (!currentFiles.has(key)) {
-        this.entries.delete(key);
+var cache_exports = {};
+__export(cache_exports, {
+  AssetCache: () => AssetCache,
+  FileCache: () => FileCache,
+  TransformCache: () => TransformCache,
+  flushCache: () => flushCache
+});
+async function flushCache() {
+  await backgroundQueue.flush();
+}
+var import_fs2, import_path, import_crypto, import_zlib, import_util, writeFile, readFile, mkdir, rename, unlink, CACHE_DIR, ASSETS_DIR, SHARDS_DIR, DEFAULT_LRU_LIMIT, DEFAULT_COMPRESS, LRUCache, BackgroundQueue, backgroundQueue, FileCache, TransformCache, AssetCache;
+var init_cache = __esm({
+  "src/node/cache.ts"() {
+    "use strict";
+    import_fs2 = __toESM(require("fs"));
+    import_path = __toESM(require("path"));
+    import_crypto = __toESM(require("crypto"));
+    import_zlib = __toESM(require("zlib"));
+    import_util = require("util");
+    init_utils();
+    writeFile = (0, import_util.promisify)(import_fs2.default.writeFile);
+    readFile = (0, import_util.promisify)(import_fs2.default.readFile);
+    mkdir = (0, import_util.promisify)(import_fs2.default.mkdir);
+    rename = (0, import_util.promisify)(import_fs2.default.rename);
+    unlink = (0, import_util.promisify)(import_fs2.default.unlink);
+    CACHE_DIR = process.env.BOLTDOCS_CACHE_DIR || ".boltdocs";
+    ASSETS_DIR = "assets";
+    SHARDS_DIR = "shards";
+    DEFAULT_LRU_LIMIT = parseInt(
+      process.env.BOLTDOCS_CACHE_LRU_LIMIT || "2000",
+      10
+    );
+    DEFAULT_COMPRESS = process.env.BOLTDOCS_CACHE_COMPRESS !== "0";
+    LRUCache = class {
+      constructor(limit) {
+        this.limit = limit;
       }
-    }
-  }
-  /** Number of cached entries */
-  get size() {
-    return this.entries.size;
+      cache = /* @__PURE__ */ new Map();
+      get(key) {
+        const val = this.cache.get(key);
+        if (val !== void 0) {
+          this.cache.delete(key);
+          this.cache.set(key, val);
+        }
+        return val;
+      }
+      set(key, value) {
+        if (this.cache.has(key)) {
+          this.cache.delete(key);
+        } else if (this.cache.size >= this.limit) {
+          const firstKey = this.cache.keys().next().value;
+          if (firstKey !== void 0) {
+            this.cache.delete(firstKey);
+          }
+        }
+        this.cache.set(key, value);
+      }
+      get size() {
+        return this.cache.size;
+      }
+      clear() {
+        this.cache.clear();
+      }
+    };
+    BackgroundQueue = class {
+      queue = Promise.resolve();
+      pendingCount = 0;
+      add(task) {
+        this.pendingCount++;
+        this.queue = this.queue.then(task).finally(() => {
+          this.pendingCount--;
+        });
+      }
+      async flush() {
+        await this.queue;
+      }
+      get pending() {
+        return this.pendingCount;
+      }
+    };
+    backgroundQueue = new BackgroundQueue();
+    FileCache = class {
+      entries = /* @__PURE__ */ new Map();
+      cachePath = null;
+      compress;
+      constructor(options = {}) {
+        this.compress = options.compress !== void 0 ? options.compress : DEFAULT_COMPRESS;
+        if (options.name) {
+          const root = options.root || process.cwd();
+          const ext = this.compress ? "json.gz" : "json";
+          this.cachePath = import_path.default.resolve(root, CACHE_DIR, `${options.name}.${ext}`);
+        }
+      }
+      /**
+       * Loads the cache. Synchronous for startup simplicity but uses fast I/O.
+       */
+      load() {
+        if (process.env.BOLTDOCS_NO_CACHE === "1") return;
+        if (!this.cachePath || !import_fs2.default.existsSync(this.cachePath)) return;
+        try {
+          let raw = import_fs2.default.readFileSync(this.cachePath);
+          if (this.cachePath.endsWith(".gz")) {
+            raw = import_zlib.default.gunzipSync(raw);
+          }
+          const data = JSON.parse(raw.toString("utf-8"));
+          this.entries = new Map(Object.entries(data));
+        } catch (e) {
+        }
+      }
+      /**
+       * Saves the cache in the background.
+       */
+      save() {
+        if (process.env.BOLTDOCS_NO_CACHE === "1") return;
+        if (!this.cachePath) return;
+        const data = Object.fromEntries(this.entries);
+        const content = JSON.stringify(data);
+        const target = this.cachePath;
+        const useCompress = this.compress;
+        backgroundQueue.add(async () => {
+          try {
+            await mkdir(import_path.default.dirname(target), { recursive: true });
+            let buffer = Buffer.from(content);
+            if (useCompress) {
+              buffer = import_zlib.default.gzipSync(buffer);
+            }
+            const tempPath = `${target}.${import_crypto.default.randomBytes(4).toString("hex")}.tmp`;
+            await writeFile(tempPath, buffer);
+            await rename(tempPath, target);
+          } catch (e) {
+          }
+        });
+      }
+      get(filePath) {
+        const entry = this.entries.get(filePath);
+        if (!entry) return null;
+        if (getFileMtime(filePath) !== entry.mtime) return null;
+        return entry.data;
+      }
+      set(filePath, data) {
+        this.entries.set(filePath, {
+          data,
+          mtime: getFileMtime(filePath)
+        });
+      }
+      isValid(filePath) {
+        const entry = this.entries.get(filePath);
+        if (!entry) return false;
+        return getFileMtime(filePath) === entry.mtime;
+      }
+      invalidate(filePath) {
+        this.entries.delete(filePath);
+      }
+      invalidateAll() {
+        this.entries.clear();
+      }
+      pruneStale(currentFiles) {
+        for (const key of this.entries.keys()) {
+          if (!currentFiles.has(key)) {
+            this.entries.delete(key);
+          }
+        }
+      }
+      get size() {
+        return this.entries.size;
+      }
+      async flush() {
+        await backgroundQueue.flush();
+      }
+    };
+    TransformCache = class {
+      index = /* @__PURE__ */ new Map();
+      // key -> hash
+      memoryCache = new LRUCache(DEFAULT_LRU_LIMIT);
+      baseDir;
+      shardsDir;
+      indexPath;
+      constructor(name, root = process.cwd()) {
+        this.baseDir = import_path.default.resolve(root, CACHE_DIR, `transform-${name}`);
+        this.shardsDir = import_path.default.resolve(this.baseDir, SHARDS_DIR);
+        this.indexPath = import_path.default.resolve(this.baseDir, "index.json");
+      }
+      /**
+       * Loads the index into memory.
+       */
+      load() {
+        if (process.env.BOLTDOCS_NO_CACHE === "1") return;
+        if (!import_fs2.default.existsSync(this.indexPath)) return;
+        try {
+          const data = import_fs2.default.readFileSync(this.indexPath, "utf-8");
+          this.index = new Map(Object.entries(JSON.parse(data)));
+        } catch (e) {
+        }
+      }
+      /**
+       * Persists the index in background.
+       */
+      save() {
+        if (process.env.BOLTDOCS_NO_CACHE === "1") return;
+        const data = JSON.stringify(Object.fromEntries(this.index));
+        const target = this.indexPath;
+        backgroundQueue.add(async () => {
+          await mkdir(import_path.default.dirname(target), { recursive: true });
+          await writeFile(target, data);
+        });
+      }
+      /**
+       * Batch Read: Retrieves multiple transformation results concurrently.
+       */
+      async getMany(keys) {
+        const results = /* @__PURE__ */ new Map();
+        const toLoad = [];
+        for (const key of keys) {
+          const mem = this.memoryCache.get(key);
+          if (mem) results.set(key, mem);
+          else if (this.index.has(key)) toLoad.push(key);
+        }
+        if (toLoad.length > 0) {
+          const shards = await Promise.all(
+            toLoad.map(async (key) => {
+              const hash = this.index.get(key);
+              const shardPath = import_path.default.resolve(this.shardsDir, `${hash}.gz`);
+              try {
+                const compressed = await readFile(shardPath);
+                const decompressed = import_zlib.default.gunzipSync(compressed).toString("utf-8");
+                this.memoryCache.set(key, decompressed);
+                return { key, val: decompressed };
+              } catch (e) {
+                return null;
+              }
+            })
+          );
+          for (const s of shards) {
+            if (s) results.set(s.key, s.val);
+          }
+        }
+        return results;
+      }
+      /**
+       * Retrieves a cached transformation. Fast lookup via index, lazy loading from disk.
+       */
+      get(key) {
+        const mem = this.memoryCache.get(key);
+        if (mem) return mem;
+        const hash = this.index.get(key);
+        if (!hash) return null;
+        const shardPath = import_path.default.resolve(this.shardsDir, `${hash}.gz`);
+        if (!import_fs2.default.existsSync(shardPath)) return null;
+        try {
+          const compressed = import_fs2.default.readFileSync(shardPath);
+          const decompressed = import_zlib.default.gunzipSync(compressed).toString("utf-8");
+          this.memoryCache.set(key, decompressed);
+          return decompressed;
+        } catch (e) {
+          return null;
+        }
+      }
+      /**
+       * Stores a transformation result.
+       */
+      set(key, result) {
+        const hash = import_crypto.default.createHash("md5").update(result).digest("hex");
+        this.index.set(key, hash);
+        this.memoryCache.set(key, result);
+        const shardPath = import_path.default.resolve(this.shardsDir, `${hash}.gz`);
+        backgroundQueue.add(async () => {
+          if (import_fs2.default.existsSync(shardPath)) return;
+          await mkdir(this.shardsDir, { recursive: true });
+          const compressed = import_zlib.default.gzipSync(Buffer.from(result));
+          const tempPath = `${shardPath}.${import_crypto.default.randomBytes(4).toString("hex")}.tmp`;
+          await writeFile(tempPath, compressed);
+          await rename(tempPath, shardPath);
+        });
+      }
+      get size() {
+        return this.index.size;
+      }
+      async flush() {
+        await backgroundQueue.flush();
+      }
+    };
+    AssetCache = class {
+      assetsDir;
+      constructor(root = process.cwd()) {
+        this.assetsDir = import_path.default.resolve(root, CACHE_DIR, ASSETS_DIR);
+      }
+      getFileHash(filePath) {
+        return import_crypto.default.createHash("md5").update(import_fs2.default.readFileSync(filePath)).digest("hex");
+      }
+      get(sourcePath, cacheKey) {
+        if (!import_fs2.default.existsSync(sourcePath)) return null;
+        const sourceHash = this.getFileHash(sourcePath);
+        const cachedPath = this.getCachedPath(
+          sourcePath,
+          `${cacheKey}-${sourceHash}`
+        );
+        return import_fs2.default.existsSync(cachedPath) ? cachedPath : null;
+      }
+      set(sourcePath, cacheKey, content) {
+        const sourceHash = this.getFileHash(sourcePath);
+        const cachedPath = this.getCachedPath(
+          sourcePath,
+          `${cacheKey}-${sourceHash}`
+        );
+        backgroundQueue.add(async () => {
+          await mkdir(this.assetsDir, { recursive: true });
+          const tempPath = `${cachedPath}.${import_crypto.default.randomBytes(4).toString("hex")}.tmp`;
+          await writeFile(tempPath, content);
+          await rename(tempPath, cachedPath);
+        });
+      }
+      getCachedPath(sourcePath, cacheKey) {
+        const ext = import_path.default.extname(sourcePath);
+        const name = import_path.default.basename(sourcePath, ext);
+        const safeKey = cacheKey.replace(/[^a-z0-9]/gi, "-").toLowerCase();
+        return import_path.default.join(this.assetsDir, `${name}.${safeKey}${ext}`);
+      }
+      clear() {
+        if (import_fs2.default.existsSync(this.assetsDir)) {
+          import_fs2.default.rmSync(this.assetsDir, { recursive: true, force: true });
+        }
+      }
+      async flush() {
+        await backgroundQueue.flush();
+      }
+    };
   }
-};
+});
+
+// src/node/index.ts
+var node_exports = {};
+__export(node_exports, {
+  default: () => boltdocs,
+  generateStaticPages: () => generateStaticPages
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/node/plugin/index.ts
+var import_vite = require("vite");
+
+// src/node/routes/index.ts
+var import_fast_glob = __toESM(require("fast-glob"));
+init_utils();
 
 // src/node/routes/cache.ts
-var docCache = new FileCache();
+init_cache();
+var docCache = new FileCache({ name: "routes" });
 function invalidateRouteCache() {
   docCache.invalidateAll();
 }
@@ -173,11 +441,12 @@ function invalidateFile(filePath) {
 }
 
 // src/node/routes/parser.ts
-var import_path = __toESM(require("path"));
+var import_path2 = __toESM(require("path"));
 var import_github_slugger = __toESM(require("github-slugger"));
+init_utils();
 function parseDocFile(file, docsDir, basePath, config) {
   const { data, content } = parseFrontmatter(file);
-  const relativePath = normalizePath(import_path.default.relative(docsDir, file));
+  const relativePath = normalizePath(import_path2.default.relative(docsDir, file));
   let parts = relativePath.split("/");
   let locale;
   let version;
@@ -209,7 +478,7 @@ function parseDocFile(file, docsDir, basePath, config) {
   const rawFileName = parts[parts.length - 1];
   const cleanFileName = stripNumberPrefix(rawFileName);
   const inferredTitle = stripNumberPrefix(
-    import_path.default.basename(file, import_path.default.extname(file))
+    import_path2.default.basename(file, import_path2.default.extname(file))
   );
   const sidebarPosition = data.sidebarPosition ?? extractNumberPrefix(rawFileName);
   const rawDirName = parts.length >= 2 ? parts[0] : void 0;
@@ -277,6 +546,7 @@ function compareByGroupPosition(a, b) {
 
 // src/node/routes/index.ts
 async function generateRoutes(docsDir, config, basePath = "/docs") {
+  docCache.load();
   const files = await (0, import_fast_glob.default)(["**/*.md", "**/*.mdx"], {
     cwd: docsDir,
     absolute: true
@@ -285,15 +555,25 @@ async function generateRoutes(docsDir, config, basePath = "/docs") {
   if (config?.i18n) {
     docCache.invalidateAll();
   }
+  let cacheHits = 0;
   const parsed = await Promise.all(
     files.map(async (file) => {
       const cached = docCache.get(file);
-      if (cached) return cached;
+      if (cached) {
+        cacheHits++;
+        return cached;
+      }
       const result = parseDocFile(file, docsDir, basePath, config);
       docCache.set(file, result);
       return result;
     })
   );
+  if (files.length > 0) {
+    console.log(
+      `[boltdocs] Routes generated: ${files.length} files (${cacheHits} from cache, ${files.length - cacheHits} parsed)`
+    );
+  }
+  docCache.save();
   const groupMeta = /* @__PURE__ */ new Map();
   for (const p of parsed) {
     if (p.relativeDir) {
@@ -371,9 +651,9 @@ async function generateRoutes(docsDir, config, basePath = "/docs") {
 var import_vite_plugin_image_optimizer = require("vite-plugin-image-optimizer");
 
 // src/node/config.ts
-var import_path2 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 var import_url = require("url");
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"));
 var CONFIG_FILES = [
   "boltdocs.config.js",
   "boltdocs.config.mjs",
@@ -382,7 +662,7 @@ var CONFIG_FILES = [
 async function resolveConfig(docsDir) {
   const projectRoot = process.cwd();
   const defaults = {
-    docsDir: import_path2.default.resolve(docsDir),
+    docsDir: import_path3.default.resolve(docsDir),
     themeConfig: {
       title: "Boltdocs",
       description: "A Vite documentation framework",
@@ -393,15 +673,15 @@ async function resolveConfig(docsDir) {
     }
   };
   for (const filename of CONFIG_FILES) {
-    const configPath = import_path2.default.resolve(projectRoot, filename);
-    if (import_fs2.default.existsSync(configPath)) {
+    const configPath = import_path3.default.resolve(projectRoot, filename);
+    if (import_fs3.default.existsSync(configPath)) {
       try {
         const fileUrl = (0, import_url.pathToFileURL)(configPath).href + "?t=" + Date.now();
         const mod = await import(fileUrl);
         const userConfig = mod.default || mod;
         const userThemeConfig = userConfig.themeConfig || userConfig;
         return {
-          docsDir: import_path2.default.resolve(docsDir),
+          docsDir: import_path3.default.resolve(docsDir),
           themeConfig: {
             ...defaults.themeConfig,
             ...userThemeConfig
@@ -420,8 +700,9 @@ async function resolveConfig(docsDir) {
 }
 
 // src/node/ssg/index.ts
-var import_fs3 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
+var import_fs4 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+init_utils();
 var import_url2 = require("url");
 var import_module = require("module");
 
@@ -486,15 +767,15 @@ ${entries.map(
 // src/node/ssg/index.ts
 var import_meta2 = {};
 var _filename = (0, import_url2.fileURLToPath)(import_meta2.url);
-var _dirname = import_path3.default.dirname(_filename);
+var _dirname = import_path4.default.dirname(_filename);
 var _require = (0, import_module.createRequire)(import_meta2.url);
 async function generateStaticPages(options) {
   const { docsDir, outDir, config } = options;
   const routes = await generateRoutes(docsDir, config);
   const siteTitle = config?.themeConfig?.title || "Boltdocs";
   const siteDescription = config?.themeConfig?.description || "";
-  const ssrModulePath = import_path3.default.resolve(_dirname, "../client/ssr.js");
-  if (!import_fs3.default.existsSync(ssrModulePath)) {
+  const ssrModulePath = import_path4.default.resolve(_dirname, "../client/ssr.js");
+  if (!import_fs4.default.existsSync(ssrModulePath)) {
     console.error(
       "[boltdocs] SSR module not found at",
       ssrModulePath,
@@ -503,12 +784,12 @@ async function generateStaticPages(options) {
     return;
   }
   const { render } = _require(ssrModulePath);
-  const templatePath = import_path3.default.join(outDir, "index.html");
-  if (!import_fs3.default.existsSync(templatePath)) {
+  const templatePath = import_path4.default.join(outDir, "index.html");
+  if (!import_fs4.default.existsSync(templatePath)) {
     console.warn("[boltdocs] No index.html found in outDir, skipping SSG.");
     return;
   }
-  const template = import_fs3.default.readFileSync(templatePath, "utf-8");
+  const template = import_fs4.default.readFileSync(templatePath, "utf-8");
   let homePageComp;
   if (config?._homePagePath) {
     try {
@@ -534,10 +815,10 @@ async function generateStaticPages(options) {
           title: escapeHtml(pageTitle),
           description: escapeHtml(pageDescription)
         }).replace("<!--app-html-->", appHtml).replace(`<div id="root"></div>`, `<div id="root">${appHtml}</div>`);
-        const routeDir = import_path3.default.join(outDir, route.path);
-        await import_fs3.default.promises.mkdir(routeDir, { recursive: true });
-        await import_fs3.default.promises.writeFile(
-          import_path3.default.join(routeDir, "index.html"),
+        const routeDir = import_path4.default.join(outDir, route.path);
+        await import_fs4.default.promises.mkdir(routeDir, { recursive: true });
+        await import_fs4.default.promises.writeFile(
+          import_path4.default.join(routeDir, "index.html"),
           html,
           "utf-8"
         );
@@ -550,16 +831,20 @@ async function generateStaticPages(options) {
     routes.map((r) => r.path),
     config
   );
-  import_fs3.default.writeFileSync(import_path3.default.join(outDir, "sitemap.xml"), sitemap, "utf-8");
+  import_fs4.default.writeFileSync(import_path4.default.join(outDir, "sitemap.xml"), sitemap, "utf-8");
   console.log(
     `[boltdocs] Generated ${routes.length} static pages + sitemap.xml`
   );
+  const { flushCache: flushCache2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
+  await flushCache2();
 }
 
 // src/node/plugin/index.ts
-var import_path4 = __toESM(require("path"));
+init_utils();
+var import_path5 = __toESM(require("path"));
 
 // src/node/plugin/entry.ts
+init_utils();
 function generateEntryCode(options, config) {
   const homeImport = options.homePage ? `import HomePage from '${normalizePath(options.homePage)}';` : "";
   const homeOption = options.homePage ? "homePage: HomePage," : "";
@@ -568,8 +853,8 @@ function generateEntryCode(options, config) {
   const componentImports = pluginComponents.map(
     ([
       name,
-      path5
-    ]) => `import * as _comp_${name} from '${normalizePath(path5)}';
+      path6
+    ]) => `import * as _comp_${name} from '${normalizePath(path6)}';
 const ${name} = _comp_${name}.default || _comp_${name}['${name}'] || _comp_${name};`
   ).join("\n");
   const componentMap = pluginComponents.map(([name]) => name).join(", ");
@@ -639,7 +924,7 @@ ${themeScript}  </head>`);
 
 // src/node/plugin/index.ts
 function boltdocsPlugin(options = {}, passedConfig) {
-  const docsDir = import_path4.default.resolve(process.cwd(), options.docsDir || "docs");
+  const docsDir = import_path5.default.resolve(process.cwd(), options.docsDir || "docs");
   const normalizedDocsDir = normalizePath(docsDir);
   let config = passedConfig;
   let viteConfig;
@@ -669,7 +954,7 @@ function boltdocsPlugin(options = {}, passedConfig) {
       },
       configureServer(server) {
         const configPaths = CONFIG_FILES.map(
-          (c) => import_path4.default.resolve(process.cwd(), c)
+          (c) => import_path5.default.resolve(process.cwd(), c)
         );
         server.watcher.add(configPaths);
         const handleFileEvent = async (file, type) => {
@@ -732,8 +1017,10 @@ function boltdocsPlugin(options = {}, passedConfig) {
       },
       async closeBundle() {
         if (!isBuild) return;
-        const outDir = viteConfig?.build?.outDir ? import_path4.default.resolve(viteConfig.root, viteConfig.build.outDir) : import_path4.default.resolve(process.cwd(), "dist");
+        const outDir = viteConfig?.build?.outDir ? import_path5.default.resolve(viteConfig.root, viteConfig.build.outDir) : import_path5.default.resolve(process.cwd(), "dist");
         await generateStaticPages({ docsDir, outDir, config });
+        const { flushCache: flushCache2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
+        await flushCache2();
       }
     },
     (0, import_vite_plugin_image_optimizer.ViteImageOptimizer)({
@@ -763,10 +1050,14 @@ var import_remark_gfm = __toESM(require("remark-gfm"));
 var import_remark_frontmatter = __toESM(require("remark-frontmatter"));
 var import_rehype_slug = __toESM(require("rehype-slug"));
 var import_rehype_pretty_code = __toESM(require("rehype-pretty-code"));
+var import_crypto2 = __toESM(require("crypto"));
+init_cache();
+var mdxCache = new TransformCache("mdx");
+var mdxCacheLoaded = false;
 function boltdocsMdxPlugin(config) {
   const extraRemarkPlugins = config?.plugins?.flatMap((p) => p.remarkPlugins || []) || [];
   const extraRehypePlugins = config?.plugins?.flatMap((p) => p.rehypePlugins || []) || [];
-  return (0, import_rollup.default)({
+  const baseMdxPlugin = (0, import_rollup.default)({
     remarkPlugins: [import_remark_gfm.default, import_remark_frontmatter.default, ...extraRemarkPlugins],
     rehypePlugins: [
       import_rehype_slug.default,
@@ -774,16 +1065,64 @@ function boltdocsMdxPlugin(config) {
       [
         import_rehype_pretty_code.default,
         {
-          theme: "one-dark-pro",
+          theme: config?.themeConfig?.codeTheme || "one-dark-pro",
           keepBackground: false
         }
       ]
     ],
-    // Provide React as default for JSX
     jsxRuntime: "automatic",
     providerImportSource: "@mdx-js/react"
   });
+  return {
+    ...baseMdxPlugin,
+    name: "vite-plugin-boltdocs-mdx",
+    async buildStart() {
+      hits = 0;
+      total = 0;
+      if (!mdxCacheLoaded) {
+        mdxCache.load();
+        mdxCacheLoaded = true;
+      }
+      if (baseMdxPlugin.buildStart) {
+        await baseMdxPlugin.buildStart.call(this);
+      }
+    },
+    async transform(code, id, options) {
+      if (!id.endsWith(".md") && !id.endsWith(".mdx")) {
+        return baseMdxPlugin.transform?.call(this, code, id, options);
+      }
+      total++;
+      const contentHash = import_crypto2.default.createHash("md5").update(code).digest("hex");
+      const cacheKey = `${id}:${contentHash}`;
+      const cached = mdxCache.get(cacheKey);
+      if (cached) {
+        hits++;
+        return { code: cached, map: null };
+      }
+      const result = await baseMdxPlugin.transform.call(
+        this,
+        code,
+        id,
+        options
+      );
+      if (result && typeof result === "object" && result.code) {
+        mdxCache.set(cacheKey, result.code);
+      } else if (typeof result === "string") {
+        mdxCache.set(cacheKey, result);
+      }
+      return result;
+    },
+    async buildEnd() {
+      mdxCache.save();
+      await mdxCache.flush();
+      if (baseMdxPlugin.buildEnd) {
+        await baseMdxPlugin.buildEnd.call(this);
+      }
+    }
+  };
 }
+var hits = 0;
+var total = 0;
 
 // src/node/index.ts
 async function boltdocs(options) {