boltdocs 1.0.0

package/dist/node/index.js

@@ -0,0 +1,797 @@
+"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 __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/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, "/");
+}
+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, "&lt;").replace(/>/g, "&gt;");
+}
+function fileToRoutePath(relativePath) {
+  let cleanedPath = relativePath.split("/").map(stripNumberPrefix).join("/");
+  let routePath = cleanedPath.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);
+}
+
+// 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);
+      }
+    }
+  }
+  /** Number of cached entries */
+  get size() {
+    return this.entries.size;
+  }
+};
+
+// src/node/routes/cache.ts
+var docCache = new FileCache();
+function invalidateRouteCache() {
+  docCache.invalidateAll();
+}
+function invalidateFile(filePath) {
+  docCache.invalidate(filePath);
+}
+
+// src/node/routes/parser.ts
+var import_path = __toESM(require("path"));
+var import_github_slugger = __toESM(require("github-slugger"));
+function parseDocFile(file, docsDir, basePath, config) {
+  const { data, content } = parseFrontmatter(file);
+  const relativePath = normalizePath(import_path.default.relative(docsDir, 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);
+    }
+  }
+  const cleanRelativePath = parts.join("/");
+  const 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_path.default.basename(file, import_path.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 });
+  }
+  return {
+    route: {
+      path: finalPath,
+      componentPath: file,
+      filePath: relativePath,
+      title: data.title || inferredTitle,
+      description: data.description || "",
+      sidebarPosition,
+      headings,
+      locale,
+      version,
+      badge: data.badge
+    },
+    relativeDir: cleanDirName,
+    isGroupIndex,
+    groupMeta: isGroupIndex ? {
+      title: data.groupTitle || data.title || (cleanDirName ? capitalize(cleanDirName) : ""),
+      position: data.groupPosition ?? data.sidebarPosition ?? (rawDirName ? extractNumberPrefix(rawDirName) : void 0)
+    } : 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") {
+  const files = await (0, import_fast_glob.default)(["**/*.md", "**/*.mdx"], {
+    cwd: docsDir,
+    absolute: true
+  });
+  docCache.pruneStale(new Set(files));
+  if (config?.i18n) {
+    docCache.invalidateAll();
+  }
+  const parsed = await Promise.all(
+    files.map(async (file) => {
+      const cached = docCache.get(file);
+      if (cached) return cached;
+      const result = parseDocFile(file, docsDir, basePath, config);
+      docCache.set(file, result);
+      return result;
+    })
+  );
+  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
+        });
+      } else {
+        const entry = groupMeta.get(p.relativeDir);
+        if (entry.position === void 0 && p.inferredGroupPosition !== void 0) {
+          entry.position = p.inferredGroupPosition;
+        }
+      }
+    }
+    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;
+      }
+    }
+  }
+  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
+    };
+  });
+  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_path2 = __toESM(require("path"));
+var import_url = require("url");
+var import_fs2 = __toESM(require("fs"));
+var CONFIG_FILES = [
+  "boltdocs.config.js",
+  "boltdocs.config.mjs",
+  "boltdocs.config.ts"
+];
+async function resolveConfig(docsDir) {
+  const projectRoot = process.cwd();
+  const defaults = {
+    docsDir: import_path2.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_path2.default.resolve(projectRoot, filename);
+    if (import_fs2.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),
+          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_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_url2 = require("url");
+var import_module = require("module");
+
+// src/node/ssg/meta.ts
+function replaceMetaTags(html, meta) {
+  return html.replace(/<title>.*?<\/title>/, `<title>${meta.title}</title>`).replace(
+    /(<meta name="description" content=")[^"]*(")/,
+    `$1${meta.description}$2`
+  ).replace(
+    /(<meta property="og:title" content=")[^"]*(")/,
+    `$1${meta.title}$2`
+  ).replace(
+    /(<meta property="og:description" content=")[^"]*(")/,
+    `$1${meta.description}$2`
+  ).replace(
+    /(<meta name="twitter:title" content=")[^"]*(")/,
+    `$1${meta.title}$2`
+  ).replace(
+    /(<meta name="twitter:description" content=")[^"]*(")/,
+    `$1${meta.description}$2`
+  );
+}
+
+// src/node/ssg/sitemap.ts
+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>${baseUrl}${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_path3.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)) {
+    console.error(
+      "[boltdocs] SSR module not found at",
+      ssrModulePath,
+      "- Did you build the core package?"
+    );
+    return;
+  }
+  const { render } = _require(ssrModulePath);
+  const templatePath = import_path3.default.join(outDir, "index.html");
+  if (!import_fs3.default.existsSync(templatePath)) {
+    console.warn("[boltdocs] No index.html found in outDir, skipping SSG.");
+    return;
+  }
+  const template = import_fs3.default.readFileSync(templatePath, "utf-8");
+  let homePageComp;
+  if (config?._homePagePath) {
+    try {
+    } catch (e) {
+    }
+  }
+  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 || {},
+          modules: fakeModules,
+          homePage: homePageComp
+        });
+        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_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"),
+          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_fs3.default.writeFileSync(import_path3.default.join(outDir, "sitemap.xml"), sitemap, "utf-8");
+  console.log(
+    `[boltdocs] Generated ${routes.length} static pages + sitemap.xml`
+  );
+}
+
+// src/node/plugin/index.ts
+var import_path4 = __toESM(require("path"));
+
+// src/node/plugin/entry.ts
+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,
+      path5
+    ]) => `import * as _comp_${name} from '${normalizePath(path5)}';
+const ${name} = _comp_${name}.default || _comp_${name}['${name}'] || _comp_${name};`
+  ).join("\n");
+  const componentMap = pluginComponents.map(([name]) => name).join(", ");
+  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,
+  config: _config,
+  modules: import.meta.glob('/docs/**/*.{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_path4.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_path4.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_path4.default.resolve(viteConfig.root, viteConfig.build.outDir) : import_path4.default.resolve(process.cwd(), "dist");
+        await generateStaticPages({ docsDir, outDir, config });
+      }
+    },
+    (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"));
+function boltdocsMdxPlugin(config) {
+  const extraRemarkPlugins = config?.plugins?.flatMap((p) => p.remarkPlugins || []) || [];
+  const extraRehypePlugins = config?.plugins?.flatMap((p) => p.rehypePlugins || []) || [];
+  return (0, import_rollup.default)({
+    remarkPlugins: [import_remark_gfm.default, import_remark_frontmatter.default, ...extraRemarkPlugins],
+    rehypePlugins: [
+      import_rehype_slug.default,
+      ...extraRehypePlugins,
+      [
+        import_rehype_pretty_code.default,
+        {
+          theme: "one-dark-pro",
+          keepBackground: false
+        }
+      ]
+    ],
+    // Provide React as default for JSX
+    jsxRuntime: "automatic",
+    providerImportSource: "@mdx-js/react"
+  });
+}
+
+// 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
+});