boltdocs 1.10.2 → 1.11.0

package/dist/node/index.js

@@ -1,1187 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-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 });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/node/utils.ts
-function normalizePath(p) {
-  return p.replace(/\\/g, "/");
-}
-function stripNumberPrefix(name) {
-  return name.replace(/^\d+\./, "");
-}
-function extractNumberPrefix(name) {
-  const match = name.match(/^(\d+)\./);
-  return match ? parseInt(match[1], 10) : void 0;
-}
-function isDocFile(filePath) {
-  return /\.mdx?$/.test(filePath);
-}
-function getFileMtime(filePath) {
-  try {
-    return import_fs.default.statSync(filePath).mtimeMs;
-  } catch {
-    return 0;
-  }
-}
-function parseFrontmatter(filePath) {
-  const raw = import_fs.default.readFileSync(filePath, "utf-8");
-  const { data, content } = (0, import_gray_matter.default)(raw);
-  return { data, content };
-}
-function escapeHtml(str) {
-  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeXml(str) {
-  return escapeHtml(str);
-}
-function fileToRoutePath(relativePath) {
-  let cleanedPath = relativePath.split("/").map(stripNumberPrefix).join("/");
-  let routePath = cleanedPath.replace(/\/$/, "");
-  routePath = routePath.replace(/\.mdx?$/, "");
-  if (routePath === "index" || routePath.endsWith("/index")) {
-    routePath = routePath.replace(/index$/, "");
-  }
-  if (!routePath.startsWith("/")) {
-    routePath = "/" + routePath;
-  }
-  if (routePath.length > 1 && routePath.endsWith("/")) {
-    routePath = routePath.slice(0, -1);
-  }
-  return routePath;
-}
-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 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;
-      }
-      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
-init_cache();
-var docCache = new FileCache({ name: "routes" });
-function invalidateRouteCache() {
-  docCache.invalidateAll();
-}
-function invalidateFile(filePath) {
-  docCache.invalidate(filePath);
-}
-
-// src/node/routes/parser.ts
-var import_path2 = __toESM(require("path"));
-var import_github_slugger = __toESM(require("github-slugger"));
-init_utils();
-function parseDocFile(file, docsDir, basePath, config) {
-  const decodedFile = decodeURIComponent(file);
-  const absoluteFile = import_path2.default.resolve(decodedFile);
-  const absoluteDocsDir = import_path2.default.resolve(docsDir);
-  const relativePath = normalizePath(
-    import_path2.default.relative(absoluteDocsDir, absoluteFile)
-  );
-  if (relativePath.startsWith("../") || relativePath === ".." || absoluteFile.includes("\0")) {
-    throw new Error(
-      `Security breach: File is outside of docs directory or contains null bytes: ${file}`
-    );
-  }
-  const { data, content } = parseFrontmatter(file);
-  let parts = relativePath.split("/");
-  let locale;
-  let version;
-  if (config?.versions && parts.length > 0) {
-    const potentialVersion = parts[0];
-    if (config.versions.versions[potentialVersion]) {
-      version = potentialVersion;
-      parts = parts.slice(1);
-    }
-  }
-  if (config?.i18n && parts.length > 0) {
-    const potentialLocale = parts[0];
-    if (config.i18n.locales[potentialLocale]) {
-      locale = potentialLocale;
-      parts = parts.slice(1);
-    }
-  }
-  let inferredTab;
-  if (parts.length > 0) {
-    const tabMatch = parts[0].match(/^\((.+)\)$/);
-    if (tabMatch) {
-      inferredTab = tabMatch[1].toLowerCase();
-      parts = parts.slice(1);
-    }
-  }
-  const cleanRelativePath = parts.join("/");
-  let cleanRoutePath;
-  if (data.permalink) {
-    cleanRoutePath = data.permalink.startsWith("/") ? data.permalink : `/${data.permalink}`;
-  } else {
-    cleanRoutePath = fileToRoutePath(cleanRelativePath || "index.md");
-  }
-  let finalPath = basePath;
-  if (version) {
-    finalPath += "/" + version;
-  }
-  if (locale) {
-    finalPath += "/" + locale;
-  }
-  finalPath += cleanRoutePath === "/" ? "" : cleanRoutePath;
-  if (!finalPath || finalPath === "") finalPath = "/";
-  const rawFileName = parts[parts.length - 1];
-  const cleanFileName = stripNumberPrefix(rawFileName);
-  const inferredTitle = stripNumberPrefix(
-    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;
-  const cleanDirName = rawDirName ? stripNumberPrefix(rawDirName) : void 0;
-  const isGroupIndex = parts.length >= 2 && /^index\.mdx?$/.test(cleanFileName);
-  const headings = [];
-  const slugger = new import_github_slugger.default();
-  const headingsRegex = /^(#{2,4})\s+(.+)$/gm;
-  let match;
-  while ((match = headingsRegex.exec(content)) !== null) {
-    const level = match[1].length;
-    const text = match[2].replace(/\[([^\]]+)\]\([^\)]+\)/g, "$1").replace(/[_*`]/g, "").trim();
-    const id = slugger.slug(text);
-    headings.push({ level, text, id });
-  }
-  const sanitizedTitle = data.title ? data.title : inferredTitle;
-  let sanitizedDescription = data.description ? data.description : "";
-  if (!sanitizedDescription && content) {
-    const summary = content.replace(/^#+.*$/gm, "").replace(/\[([^\]]+)\]\([^\)]+\)/g, "$1").replace(/[_*`]/g, "").replace(/\n+/g, " ").trim().slice(0, 160);
-    sanitizedDescription = summary;
-  }
-  const sanitizedBadge = data.badge ? data.badge : void 0;
-  const icon = data.icon ? String(data.icon) : void 0;
-  const plainText = content.replace(/^#+.*$/gm, "").replace(/\[([^\]]+)\]\([^\)]+\)/g, "$1").replace(/<[^>]+>/g, "").replace(/\{[^\}]+\}/g, "").replace(/[_*`]/g, "").replace(/\n+/g, " ").trim();
-  return {
-    route: {
-      path: finalPath,
-      componentPath: file,
-      filePath: relativePath,
-      title: sanitizedTitle,
-      description: sanitizedDescription,
-      sidebarPosition,
-      headings,
-      locale,
-      version,
-      badge: sanitizedBadge,
-      icon,
-      tab: inferredTab,
-      _content: plainText,
-      _rawContent: content
-    },
-    relativeDir: cleanDirName,
-    isGroupIndex,
-    inferredTab,
-    groupMeta: isGroupIndex ? {
-      title: data.groupTitle || data.title || (cleanDirName ? capitalize(cleanDirName) : ""),
-      position: data.groupPosition ?? data.sidebarPosition ?? (rawDirName ? extractNumberPrefix(rawDirName) : void 0),
-      icon
-    } : void 0,
-    inferredGroupPosition: rawDirName ? extractNumberPrefix(rawDirName) : void 0
-  };
-}
-
-// src/node/routes/sorter.ts
-function sortRoutes(routes) {
-  return routes.sort((a, b) => {
-    if (!a.group && !b.group) return compareByPosition(a, b);
-    if (!a.group) return -1;
-    if (!b.group) return 1;
-    if (a.group !== b.group) {
-      return compareByGroupPosition(a, b);
-    }
-    return compareByPosition(a, b);
-  });
-}
-function compareByPosition(a, b) {
-  if (a.sidebarPosition !== void 0 && b.sidebarPosition !== void 0)
-    return a.sidebarPosition - b.sidebarPosition;
-  if (a.sidebarPosition !== void 0) return -1;
-  if (b.sidebarPosition !== void 0) return 1;
-  return a.title.localeCompare(b.title);
-}
-function compareByGroupPosition(a, b) {
-  if (a.groupPosition !== void 0 && b.groupPosition !== void 0)
-    return a.groupPosition - b.groupPosition;
-  if (a.groupPosition !== void 0) return -1;
-  if (b.groupPosition !== void 0) return 1;
-  return (a.groupTitle || a.group).localeCompare(b.groupTitle || b.group);
-}
-
-// src/node/routes/index.ts
-async function generateRoutes(docsDir, config, basePath = "/docs") {
-  docCache.load();
-  docCache.invalidateAll();
-  const files = await (0, import_fast_glob.default)(["**/*.md", "**/*.mdx"], {
-    cwd: docsDir,
-    absolute: true
-  });
-  docCache.pruneStale(new Set(files));
-  if (config?.i18n) {
-    docCache.invalidateAll();
-  }
-  let cacheHits = 0;
-  const parsed = await Promise.all(
-    files.map(async (file) => {
-      const cached = docCache.get(file);
-      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) {
-      if (!groupMeta.has(p.relativeDir)) {
-        groupMeta.set(p.relativeDir, {
-          title: capitalize(p.relativeDir),
-          position: p.inferredGroupPosition,
-          icon: p.route.icon
-        });
-      } else {
-        const entry = groupMeta.get(p.relativeDir);
-        if (entry.position === void 0 && p.inferredGroupPosition !== void 0) {
-          entry.position = p.inferredGroupPosition;
-        }
-        if (!entry.icon && p.route.icon) {
-          entry.icon = p.route.icon;
-        }
-      }
-    }
-    if (p.isGroupIndex && p.relativeDir && p.groupMeta) {
-      const entry = groupMeta.get(p.relativeDir);
-      entry.title = p.groupMeta.title;
-      if (p.groupMeta.position !== void 0) {
-        entry.position = p.groupMeta.position;
-      }
-      if (p.groupMeta.icon) {
-        entry.icon = p.groupMeta.icon;
-      }
-    }
-  }
-  const routes = parsed.map((p) => {
-    const dir = p.relativeDir;
-    const meta = dir ? groupMeta.get(dir) : void 0;
-    return {
-      ...p.route,
-      group: dir,
-      groupTitle: meta?.title || (dir ? capitalize(dir) : void 0),
-      groupPosition: meta?.position,
-      groupIcon: meta?.icon
-    };
-  });
-  if (config?.i18n) {
-    const defaultLocale = config.i18n.defaultLocale;
-    const allLocales = Object.keys(config.i18n.locales);
-    const fallbackRoutes = [];
-    const defaultRoutes = routes.filter(
-      (r) => (r.locale || defaultLocale) === defaultLocale
-    );
-    for (const locale of allLocales) {
-      if (locale === defaultLocale) continue;
-      const localeRoutePaths = new Set(
-        routes.filter((r) => r.locale === locale).map((r) => r.path)
-      );
-      for (const defRoute of defaultRoutes) {
-        let prefix = basePath;
-        if (defRoute.version) {
-          prefix += "/" + defRoute.version;
-        }
-        let pathAfterVersion = defRoute.path.substring(prefix.length);
-        if (pathAfterVersion.startsWith("/" + defaultLocale + "/")) {
-          pathAfterVersion = pathAfterVersion.substring(
-            defaultLocale.length + 1
-          );
-        } else if (pathAfterVersion === "/" + defaultLocale) {
-          pathAfterVersion = "/";
-        }
-        const targetPath = prefix + "/" + locale + (pathAfterVersion === "/" || pathAfterVersion === "" ? "" : pathAfterVersion);
-        if (!localeRoutePaths.has(targetPath)) {
-          fallbackRoutes.push({
-            ...defRoute,
-            path: targetPath,
-            locale
-          });
-        }
-      }
-    }
-    return sortRoutes([...routes, ...fallbackRoutes]);
-  }
-  return sortRoutes(routes);
-}
-
-// src/node/plugin/index.ts
-var import_vite_plugin_image_optimizer = require("vite-plugin-image-optimizer");
-
-// src/node/config.ts
-var import_path3 = __toESM(require("path"));
-var import_url = require("url");
-var import_fs3 = __toESM(require("fs"));
-var CONFIG_FILES = [
-  "boltdocs.config.js",
-  "boltdocs.config.mjs",
-  "boltdocs.config.ts"
-];
-async function resolveConfig(docsDir, root = process.cwd()) {
-  const projectRoot = root;
-  const defaults = {
-    docsDir: import_path3.default.resolve(docsDir),
-    themeConfig: {
-      title: "Boltdocs",
-      description: "A Vite documentation framework",
-      navbar: [
-        { text: "Home", link: "/" },
-        { text: "Documentation", link: "/docs" }
-      ]
-    }
-  };
-  for (const filename of CONFIG_FILES) {
-    const configPath = import_path3.default.resolve(projectRoot, filename);
-    if (import_fs3.default.existsSync(configPath)) {
-      try {
-        const isTest = process.env.NODE_ENV === "test" || global.__vitest_worker__;
-        const fileUrl = (0, import_url.pathToFileURL)(configPath).href + (isTest ? "" : "?t=" + Date.now());
-        const mod = await import(fileUrl);
-        const userConfig = mod.default || mod;
-        const userThemeConfig = userConfig.themeConfig || userConfig;
-        return {
-          docsDir: import_path3.default.resolve(docsDir),
-          themeConfig: {
-            ...defaults.themeConfig,
-            ...userThemeConfig
-          },
-          i18n: userConfig.i18n,
-          versions: userConfig.versions,
-          siteUrl: userConfig.siteUrl,
-          plugins: userConfig.plugins || []
-        };
-      } catch (e) {
-        console.warn(`[boltdocs] Failed to load config from ${filename}:`, e);
-      }
-    }
-  }
-  return defaults;
-}
-
-// src/node/ssg/index.ts
-var import_fs4 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
-init_utils();
-var import_url2 = require("url");
-var import_module = require("module");
-
-// src/node/ssg/meta.ts
-init_utils();
-function replaceMetaTags(html, meta) {
-  const title = escapeHtml(meta.title);
-  const description = escapeHtml(meta.description);
-  return html.replace(/<title>.*?<\/title>/, `<title>${title}</title>`).replace(
-    /(<meta name="description" content=")[^"]*(")/,
-    `$1${description}$2`
-  ).replace(/(<meta property="og:title" content=")[^"]*(")/, `$1${title}$2`).replace(
-    /(<meta property="og:description" content=")[^"]*(")/,
-    `$1${description}$2`
-  ).replace(/(<meta name="twitter:title" content=")[^"]*(")/, `$1${title}$2`).replace(
-    /(<meta name="twitter:description" content=")[^"]*(")/,
-    `$1${description}$2`
-  );
-}
-
-// src/node/ssg/sitemap.ts
-init_utils();
-function generateSitemap(routePaths, config) {
-  const baseUrl = config?.siteUrl?.replace(/\/$/, "") || "https://example.com";
-  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const rootEntries = [{ url: "/", priority: "1.0", changefreq: "daily" }];
-  if (config?.i18n) {
-    const defaultLocale = config.i18n.defaultLocale;
-    for (const locale of Object.keys(config.i18n.locales)) {
-      if (locale !== defaultLocale) {
-        rootEntries.push({
-          url: `/${locale}/`,
-          priority: "1.0",
-          changefreq: "daily"
-        });
-      }
-    }
-  }
-  const entries = [
-    ...rootEntries,
-    ...routePaths.map((p) => ({
-      url: p,
-      priority: "0.8",
-      changefreq: "weekly"
-    }))
-  ];
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${entries.map(
-    (e) => `  <url>
-    <loc>${escapeXml(baseUrl)}${escapeXml(e.url)}</loc>
-    <lastmod>${today}</lastmod>
-    <changefreq>${e.changefreq}</changefreq>
-    <priority>${e.priority}</priority>
-  </url>`
-  ).join("\n")}
-</urlset>`;
-}
-
-// src/node/ssg/index.ts
-var import_meta2 = {};
-var _filename = (0, import_url2.fileURLToPath)(import_meta2.url);
-var _dirname = import_path4.default.dirname(_filename);
-var _require = (0, import_module.createRequire)(import_meta2.url);
-async function generateStaticPages(options) {
-  const { docsDir, docsDirName, outDir, config } = options;
-  const routes = await generateRoutes(docsDir, config);
-  const siteTitle = config?.themeConfig?.title || "Boltdocs";
-  const siteDescription = config?.themeConfig?.description || "";
-  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,
-      "- Did you build the core package?"
-    );
-    return;
-  }
-  const { render } = _require(ssrModulePath);
-  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_fs4.default.readFileSync(templatePath, "utf-8");
-  await Promise.all(
-    routes.map(async (route) => {
-      const pageTitle = `${route.title} | ${siteTitle}`;
-      const pageDescription = route.description || siteDescription;
-      const fakeModules = {};
-      fakeModules[route.componentPath] = { default: () => {
-      } };
-      try {
-        const appHtml = await render({
-          path: route.path,
-          routes,
-          config: config || {},
-          docsDirName,
-          modules: fakeModules,
-          homePage: void 0
-          // No custom home page for now
-        });
-        const html = replaceMetaTags(template, {
-          title: escapeHtml(pageTitle),
-          description: escapeHtml(pageDescription)
-        }).replace("<!--app-html-->", appHtml).replace(`<div id="root"></div>`, `<div id="root">${appHtml}</div>`);
-        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"
-        );
-      } catch (e) {
-        console.error(`[boltdocs] Error SSR rendering route ${route.path}:`, e);
-      }
-    })
-  );
-  const sitemap = generateSitemap(
-    routes.map((r) => r.path),
-    config
-  );
-  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
-init_utils();
-var import_path6 = __toESM(require("path"));
-
-// src/node/plugin/entry.ts
-init_utils();
-var import_path5 = __toESM(require("path"));
-function generateEntryCode(options, config) {
-  const homeImport = options.homePage ? `import HomePage from '${normalizePath(options.homePage)}';` : "";
-  const homeOption = options.homePage ? "homePage: HomePage," : "";
-  const customCssImport = options.customCss ? `import '${normalizePath(options.customCss)}';` : "";
-  const pluginComponents = config?.plugins?.flatMap((p) => Object.entries(p.components || {})) || [];
-  const componentImports = pluginComponents.map(
-    ([
-      name,
-      path7
-    ]) => `import * as _comp_${name} from '${normalizePath(path7)}';
-const ${name} = _comp_${name}.default || _comp_${name}['${name}'] || _comp_${name};`
-  ).join("\n");
-  const componentMap = pluginComponents.map(([name]) => name).join(", ");
-  const docsDirName = import_path5.default.basename(options.docsDir || "docs");
-  return `
-import { createBoltdocsApp as _createApp } from 'boltdocs/client';
-import 'boltdocs/style.css';
-${customCssImport}
-import _routes from 'virtual:boltdocs-routes';
-import _config from 'virtual:boltdocs-config';
-${homeImport}
-${componentImports}
-
-_createApp({
-  target: '#root',
-  routes: _routes,
-  docsDirName: '${docsDirName}',
-  config: _config,
-  modules: import.meta.glob('/${docsDirName}/**/*.{md,mdx}'),
-  hot: import.meta.hot,
-  ${homeOption}
-  components: { ${componentMap} },
-});
-`;
-}
-
-// src/node/plugin/html.ts
-function injectHtmlMeta(html, config) {
-  const title = config.themeConfig?.title || "Boltdocs";
-  const description = config.themeConfig?.description || "";
-  const seoTags = [
-    `<meta name="description" content="${description}">`,
-    `<meta property="og:title" content="${title}">`,
-    `<meta property="og:description" content="${description}">`,
-    `<meta property="og:type" content="website">`,
-    `<meta name="twitter:card" content="summary">`,
-    `<meta name="twitter:title" content="${title}">`,
-    `<meta name="twitter:description" content="${description}">`,
-    `<meta name="generator" content="Boltdocs">`
-  ].join("\n    ");
-  const themeScript = `
-    <script>
-      (function() {
-        try {
-          var stored = localStorage.getItem("boltdocs-theme");
-          var theme = stored || (window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light");
-          if (theme === "light") {
-            document.documentElement.classList.add("theme-light");
-            document.documentElement.dataset.theme = "light";
-          } else {
-            document.documentElement.classList.remove("theme-light");
-            document.documentElement.dataset.theme = "dark";
-          }
-        } catch (e) {}
-      })();
-    </script>
-  `;
-  html = html.replace(/<title>.*?<\/title>/, `<title>${title}</title>`);
-  html = html.replace("</head>", `    ${seoTags}
-${themeScript}  </head>`);
-  if (!html.includes("src/main")) {
-    html = html.replace(
-      "</body>",
-      '  <script type="module">import "virtual:boltdocs-entry";</script>\n  </body>'
-    );
-  }
-  return html;
-}
-
-// src/node/plugin/index.ts
-function boltdocsPlugin(options = {}, passedConfig) {
-  const docsDir = import_path6.default.resolve(process.cwd(), options.docsDir || "docs");
-  const normalizedDocsDir = normalizePath(docsDir);
-  let config = passedConfig;
-  let viteConfig;
-  let isBuild = false;
-  const extraVitePlugins = config?.plugins?.flatMap((p) => p.vitePlugins || []) || [];
-  return [
-    {
-      name: "vite-plugin-boltdocs",
-      enforce: "pre",
-      async config(userConfig, env) {
-        isBuild = env.command === "build";
-        const envDir = userConfig.envDir || process.cwd();
-        const envs = (0, import_vite.loadEnv)(env.mode, envDir, "");
-        Object.assign(process.env, envs);
-        if (!config) {
-          config = await resolveConfig(docsDir);
-        }
-        if (!options.customCss && config.themeConfig?.customCss) {
-          options.customCss = config.themeConfig.customCss;
-        }
-        return {
-          optimizeDeps: { include: ["react", "react-dom"] }
-        };
-      },
-      configResolved(resolved) {
-        viteConfig = resolved;
-      },
-      configureServer(server) {
-        const configPaths = CONFIG_FILES.map(
-          (c) => import_path6.default.resolve(process.cwd(), c)
-        );
-        server.watcher.add(configPaths);
-        const handleFileEvent = async (file, type) => {
-          const normalized = normalizePath(file);
-          if (CONFIG_FILES.some((c) => normalized.endsWith(c))) {
-            server.restart();
-            return;
-          }
-          if (!normalized.startsWith(normalizedDocsDir) || !isDocFile(normalized))
-            return;
-          if (type === "add" || type === "unlink") {
-            invalidateRouteCache();
-          } else {
-            invalidateFile(file);
-          }
-          const newRoutes = await generateRoutes(docsDir, config);
-          const routesMod = server.moduleGraph.getModuleById(
-            "\0virtual:boltdocs-routes"
-          );
-          if (routesMod) server.moduleGraph.invalidateModule(routesMod);
-          server.ws.send({
-            type: "custom",
-            event: "boltdocs:routes-update",
-            data: newRoutes
-          });
-        };
-        server.watcher.on("add", (f) => handleFileEvent(f, "add"));
-        server.watcher.on("unlink", (f) => handleFileEvent(f, "unlink"));
-        server.watcher.on("change", (f) => handleFileEvent(f, "change"));
-      },
-      resolveId(id) {
-        if (id === "virtual:boltdocs-routes" || id === "virtual:boltdocs-config" || id === "virtual:boltdocs-entry") {
-          return "\0" + id;
-        }
-      },
-      async load(id) {
-        if (id === "\0virtual:boltdocs-routes") {
-          const routes = await generateRoutes(docsDir, config);
-          return `export default ${JSON.stringify(routes, null, 2)};`;
-        }
-        if (id === "\0virtual:boltdocs-config") {
-          const clientConfig = {
-            themeConfig: config?.themeConfig,
-            i18n: config?.i18n,
-            versions: config?.versions,
-            siteUrl: config?.siteUrl
-          };
-          return `export default ${JSON.stringify(clientConfig, null, 2)};`;
-        }
-        if (id === "\0virtual:boltdocs-entry") {
-          const code = generateEntryCode(options, config);
-          return code;
-        }
-      },
-      transformIndexHtml: {
-        order: "pre",
-        handler(html) {
-          return injectHtmlMeta(html, config);
-        }
-      },
-      async closeBundle() {
-        if (!isBuild) return;
-        const outDir = viteConfig?.build?.outDir ? import_path6.default.resolve(viteConfig.root, viteConfig.build.outDir) : import_path6.default.resolve(process.cwd(), "dist");
-        const docsDirName = import_path6.default.basename(docsDir || "docs");
-        await generateStaticPages({ docsDir, docsDirName, outDir, config });
-        const { flushCache: flushCache2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
-        await flushCache2();
-      }
-    },
-    (0, import_vite_plugin_image_optimizer.ViteImageOptimizer)({
-      includePublic: true,
-      png: { quality: 80 },
-      jpeg: { quality: 80 },
-      jpg: { quality: 80 },
-      webp: { quality: 80 },
-      avif: { quality: 80 },
-      svg: {
-        multipass: true,
-        plugins: [
-          {
-            name: "preset-default",
-            params: { overrides: { removeViewBox: false } }
-          }
-        ]
-      }
-    }),
-    ...extraVitePlugins.filter((p) => !!p)
-  ];
-}
-
-// src/node/mdx.ts
-var import_rollup = __toESM(require("@mdx-js/rollup"));
-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, compiler = import_rollup.default) {
-  const extraRemarkPlugins = config?.plugins?.flatMap((p) => p.remarkPlugins || []) || [];
-  const extraRehypePlugins = config?.plugins?.flatMap((p) => p.rehypePlugins || []) || [];
-  const baseMdxPlugin = compiler({
-    remarkPlugins: [import_remark_gfm.default, import_remark_frontmatter.default, ...extraRemarkPlugins],
-    rehypePlugins: [
-      import_rehype_slug.default,
-      ...extraRehypePlugins,
-      [
-        import_rehype_pretty_code.default,
-        {
-          theme: config?.themeConfig?.codeTheme || "one-dark-pro",
-          keepBackground: false
-        }
-      ]
-    ],
-    jsxRuntime: "automatic",
-    providerImportSource: "@mdx-js/react"
-  });
-  if (baseMdxPlugin.isMock) {
-    console.log("MDX PLUGIN IS MOCKED");
-  }
-  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);
-      }
-      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) {
-  const docsDir = options?.docsDir || "docs";
-  const config = await resolveConfig(docsDir);
-  return [...boltdocsPlugin(options, config), boltdocsMdxPlugin(config)];
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  generateStaticPages
-});