boltdocs 1.0.1 → 1.3.0

package/dist/{CodeBlock-37XMKCYY.mjs → CodeBlock-V3Z5EKGR.mjs}

@@ -1,7 +1,6 @@
 import {
   CodeBlock
 } from "./chunk-2YRDWM6O.mjs";
-import "./chunk-X6BYQHVC.mjs";
 export {
   CodeBlock
 };

package/dist/{PackageManagerTabs-4NWXLXQO.mjs → PackageManagerTabs-XEKI3L7P.mjs}

@@ -1,5 +1,3 @@
-import "./chunk-X6BYQHVC.mjs";
-
 // src/client/theme/components/PackageManagerTabs/PackageManagerTabs.tsx
 import { useState, useCallback } from "react";
 import { Copy, Check } from "lucide-react";

package/dist/{SearchDialog-FTOQZ763.mjs → SearchDialog-5EDRACEG.mjs}

@@ -1,7 +1,6 @@
 import {
   Link
-} from "./chunk-ZFCOLEXN.mjs";
-import "./chunk-X6BYQHVC.mjs";
+} from "./chunk-NS7WHDYA.mjs";
 
 // src/client/theme/ui/SearchDialog/SearchDialog.tsx
 import React, { useState, useEffect, useRef } from "react";

package/dist/{SearchDialog-ZAZXYIFX.css → SearchDialog-X57WPTNN.css}

@@ -422,73 +422,43 @@ a {
   flex: 1;
 }
 .boltdocs-main-container.sidebar-collapsed .boltdocs-sidebar {
-  width: 0;
-  padding-left: 0;
-  padding-right: 0;
-  border-right-color: transparent;
-  opacity: 0;
-  pointer-events: none;
+  width: 54px;
+  padding: 1rem 0;
+  border-right: 1px solid var(--ld-border-subtle);
+  opacity: 1;
+  pointer-events: auto;
   overflow: hidden;
 }
-.sidebar-toggle-floating {
-  position: fixed;
-  bottom: 2rem;
-  left: 2rem;
-  width: 2.75rem;
-  height: 2.75rem;
-  border-radius: 50%;
-  background-color: var(--ld-surface);
-  border: 1px solid var(--ld-border-strong);
-  color: var(--ld-text-muted);
+.sidebar-collapse {
+  width: 100%;
   display: flex;
   align-items: center;
-  justify-content: center;
-  cursor: pointer;
-  z-index: 100;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
-  transition: all 0.3s cubic-bezier(0.16, 1, 0.3, 1);
-  opacity: 0;
-  pointer-events: none;
-  transform: translateY(20px) scale(0.9);
-}
-.sidebar-toggle-floating:hover {
-  background-color: var(--ld-bg-soft);
-  color: var(--ld-text-main);
-  transform: translateY(0px) scale(1.05);
-  border-color: var(--ld-color-primary);
+  justify-content: flex-end;
+  padding: 0 0.75rem 1rem;
+  transition: justify-content 0.3s ease;
 }
-.sidebar-toggle-floating:active {
-  transform: translateY(0px) scale(0.95);
-}
-.boltdocs-main-container.sidebar-collapsed .sidebar-toggle-floating {
-  opacity: 1;
-  pointer-events: auto;
-  transform: translateY(0) scale(1);
-}
-.sidebar-footer {
-  margin-top: 2rem;
-  padding-top: 1rem;
-  border-top: 1px solid var(--ld-border-subtle);
+.boltdocs-main-container.sidebar-collapsed .sidebar-collapse {
+  justify-content: center;
+  padding: 0 0 1rem;
 }
 .sidebar-collapse-btn {
+  color: var(--ld-text-muted);
+  border: none;
+  box-shadow: none;
+  background-color: transparent;
+  cursor: pointer;
   display: flex;
   align-items: center;
-  gap: 0.5rem;
-  width: 100%;
-  padding: 0.5rem 0.75rem;
-  background: none;
-  border: none;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
   border-radius: var(--ld-radius-md);
-  color: var(--ld-text-muted);
-  font-family: var(--ld-font-sans);
-  font-size: 0.8125rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: all 0.2s ease;
+  transition: all 0.2s cubic-bezier(0.16, 1, 0.3, 1);
 }
 .sidebar-collapse-btn:hover {
-  background-color: var(--ld-bg-soft);
-  color: var(--ld-color-primary);
+  background-color: var(--ld-bg-mute);
+  color: var(--ld-text-main);
+  transform: scale(1.05);
 }
 .boltdocs-sidebar::-webkit-scrollbar {
   width: 4px;
@@ -1142,11 +1112,11 @@ a {
   background-color: transparent !important;
 }
 .code-block-wrapper pre > code {
-  padding: 1.25rem !important;
-  display: block !important;
+  display: grid !important;
+  padding: 1.25rem 1rem !important;
 }
 .code-block-wrapper pre > code .line {
-  padding: 0;
+  padding: 0 1.25rem;
 }
 .boltdocs-page pre {
   margin: 1.5rem 0;
@@ -1161,7 +1131,7 @@ a {
 }
 .boltdocs-page pre > code {
   display: grid;
-  padding: 1rem 0;
+  padding: 1rem 1rem;
   background-color: transparent;
   border: none;
   color: inherit;
@@ -1245,57 +1215,68 @@ a {
 
 /* src/client/theme/components/mdx/mdx-components.css */
 .ld-btn {
+  all: unset;
+  box-sizing: border-box !important;
   display: inline-flex;
   align-items: center;
-  gap: 0.4rem;
+  justify-content: center;
+  gap: 0.5rem;
+  font-family: var(--ld-font-sans);
   font-weight: 600;
+  font-size: 0.9375rem;
+  line-height: normal;
+  letter-spacing: -0.01em;
+  text-align: center;
+  text-decoration: none !important;
+  white-space: nowrap;
   border-radius: var(--ld-radius-md);
   cursor: pointer;
-  transition: all 300ms cubic-bezier(0.16, 1, 0.3, 1);
-  font-family: var(--ld-font-sans);
+  transition: all 250ms cubic-bezier(0.4, 0, 0.2, 1);
   border: 1px solid transparent;
-  line-height: 1;
-  letter-spacing: -0.01em;
+  user-select: none;
+  position: relative;
 }
 .ld-btn:hover {
-  transform: scale(1.05);
+  transform: translateY(-1px);
 }
 .ld-btn:active {
-  transform: scale(0.95);
+  transform: translateY(0) scale(0.98);
 }
 .ld-btn--sm {
-  padding: 0.45rem 1.1rem;
+  min-height: 2rem;
+  padding: 0 1rem;
   font-size: 0.8125rem;
   border-radius: var(--ld-radius-md);
 }
 .ld-btn--md {
-  padding: 0.7rem 1.6rem;
+  min-height: 2.625rem;
+  padding: 0 1.6rem;
   font-size: 0.9375rem;
 }
 .ld-btn--lg {
-  padding: 0.85rem 2.1rem;
+  min-height: 3.25rem;
+  padding: 0 2.2rem;
   font-size: 1.05rem;
 }
 .ld-btn--primary {
-  background-color: var(--ld-ui-btn-primary-bg, var(--ld-btn-primary-bg));
+  background-color: var( --ld-ui-btn-primary-bg, var(--ld-btn-primary-bg) ) !important;
   color: var(--ld-ui-btn-primary-text, var(--ld-btn-primary-text)) !important;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
 }
 .ld-btn--primary:hover {
-  opacity: 0.92;
-  color: var(--ld-ui-btn-primary-text, var(--ld-btn-primary-text)) !important;
+  filter: brightness(1.1);
 }
 .ld-btn--secondary {
-  background-color: var(--ld-ui-btn-secondary-bg, var(--ld-btn-secondary-bg));
+  background-color: var( --ld-ui-btn-secondary-bg, var(--ld-btn-secondary-bg) ) !important;
   color: var( --ld-ui-btn-secondary-text, var(--ld-btn-secondary-text) ) !important;
   border-color: var(--ld-border-subtle);
 }
 .ld-btn--secondary:hover {
   background-color: var(--ld-bg-mute);
   border-color: var(--ld-border-strong);
-  color: var( --ld-ui-btn-secondary-text, var(--ld-btn-secondary-text) ) !important;
 }
 .ld-btn--outline {
-  background: transparent;
+  background: transparent !important;
   color: var(--ld-text-main) !important;
   border-color: var(--ld-border-strong);
 }
@@ -1304,7 +1285,7 @@ a {
   border-color: var(--ld-color-primary);
 }
 .ld-btn--ghost {
-  background: transparent;
+  background: transparent !important;
   color: var(--ld-text-muted) !important;
 }
 .ld-btn--ghost:hover {
@@ -1840,56 +1821,6 @@ a {
   color: var(--ld-color-primary);
 }
 
-/* src/client/theme/styles/home.css */
-.boltdocs-home {
-  min-height: calc(100vh - var(--ld-navbar-height));
-}
-.home-hero {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 6rem 2rem 4rem;
-  text-align: center;
-}
-.hero-content {
-  max-width: 680px;
-}
-.hero-title {
-  font-size: 3.5rem;
-  font-weight: 900;
-  line-height: 1.1;
-  margin: 0 0 1.25rem;
-  letter-spacing: -0.03em;
-  color: var(--ld-text-main);
-}
-.hero-highlight {
-  background:
-    linear-gradient(
-      135deg,
-      var(--ld-gradient-from),
-      var(--ld-gradient-to));
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-}
-.hero-description {
-  font-size: 1.125rem;
-  color: var(--ld-text-muted);
-  line-height: 1.7;
-  margin-bottom: 2rem;
-}
-.hero-actions {
-  display: flex;
-  gap: 0.75rem;
-  justify-content: center;
-  flex-wrap: wrap;
-}
-.home-features {
-  padding: 2rem 2rem 6rem;
-  max-width: 1000px;
-  margin: 0 auto;
-}
-
 /* src/client/theme/ui/NotFound/not-found.css */
 .boltdocs-not-found {
   display: flex;
@@ -2122,9 +2053,6 @@ a.not-found-link:hover {
   .boltdocs-sidebar {
     display: none;
   }
-  .sidebar-toggle-floating {
-    display: none !important;
-  }
   .boltdocs-content {
     padding: 1.5rem 1rem 3rem;
   }

package/dist/{Video-I6QY4X7J.mjs → Video-KNTY5BNO.mjs}

@@ -1,7 +1,6 @@
 import {
   Video
 } from "./chunk-Z7JHYNAS.mjs";
-import "./chunk-X6BYQHVC.mjs";
 export {
   Video
 };

package/dist/cache-EHR7SXRU.mjs

@@ -0,0 +1,12 @@
+import {
+  AssetCache,
+  FileCache,
+  TransformCache,
+  flushCache
+} from "./chunk-GSYECEZY.mjs";
+export {
+  AssetCache,
+  FileCache,
+  TransformCache,
+  flushCache
+};

package/dist/chunk-GSYECEZY.mjs

@@ -0,0 +1,381 @@
+// src/node/cache.ts
+import fs2 from "fs";
+import path from "path";
+import crypto from "crypto";
+import zlib from "zlib";
+import { promisify } from "util";
+
+// src/node/utils.ts
+import fs from "fs";
+import matter from "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 fs.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function parseFrontmatter(filePath) {
+  const raw = fs.readFileSync(filePath, "utf-8");
+  const { data, content } = matter(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 writeFile = promisify(fs2.writeFile);
+var readFile = promisify(fs2.readFile);
+var mkdir = promisify(fs2.mkdir);
+var rename = promisify(fs2.rename);
+var unlink = promisify(fs2.unlink);
+var CACHE_DIR = process.env.BOLTDOCS_CACHE_DIR || ".boltdocs";
+var ASSETS_DIR = "assets";
+var SHARDS_DIR = "shards";
+var DEFAULT_LRU_LIMIT = parseInt(
+  process.env.BOLTDOCS_CACHE_LRU_LIMIT || "2000",
+  10
+);
+var DEFAULT_COMPRESS = process.env.BOLTDOCS_CACHE_COMPRESS !== "0";
+var 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();
+  }
+};
+var 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;
+  }
+};
+var backgroundQueue = new BackgroundQueue();
+var 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 = path.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 || !fs2.existsSync(this.cachePath)) return;
+    try {
+      let raw = fs2.readFileSync(this.cachePath);
+      if (this.cachePath.endsWith(".gz")) {
+        raw = zlib.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(path.dirname(target), { recursive: true });
+        let buffer = Buffer.from(content);
+        if (useCompress) {
+          buffer = zlib.gzipSync(buffer);
+        }
+        const tempPath = `${target}.${crypto.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();
+  }
+};
+var TransformCache = class {
+  index = /* @__PURE__ */ new Map();
+  // key -> hash
+  memoryCache = new LRUCache(DEFAULT_LRU_LIMIT);
+  baseDir;
+  shardsDir;
+  indexPath;
+  constructor(name, root = process.cwd()) {
+    this.baseDir = path.resolve(root, CACHE_DIR, `transform-${name}`);
+    this.shardsDir = path.resolve(this.baseDir, SHARDS_DIR);
+    this.indexPath = path.resolve(this.baseDir, "index.json");
+  }
+  /**
+   * Loads the index into memory.
+   */
+  load() {
+    if (process.env.BOLTDOCS_NO_CACHE === "1") return;
+    if (!fs2.existsSync(this.indexPath)) return;
+    try {
+      const data = fs2.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(path.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 = path.resolve(this.shardsDir, `${hash}.gz`);
+          try {
+            const compressed = await readFile(shardPath);
+            const decompressed = zlib.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 = path.resolve(this.shardsDir, `${hash}.gz`);
+    if (!fs2.existsSync(shardPath)) return null;
+    try {
+      const compressed = fs2.readFileSync(shardPath);
+      const decompressed = zlib.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 = crypto.createHash("md5").update(result).digest("hex");
+    this.index.set(key, hash);
+    this.memoryCache.set(key, result);
+    const shardPath = path.resolve(this.shardsDir, `${hash}.gz`);
+    backgroundQueue.add(async () => {
+      if (fs2.existsSync(shardPath)) return;
+      await mkdir(this.shardsDir, { recursive: true });
+      const compressed = zlib.gzipSync(Buffer.from(result));
+      const tempPath = `${shardPath}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+      await writeFile(tempPath, compressed);
+      await rename(tempPath, shardPath);
+    });
+  }
+  get size() {
+    return this.index.size;
+  }
+  async flush() {
+    await backgroundQueue.flush();
+  }
+};
+var AssetCache = class {
+  assetsDir;
+  constructor(root = process.cwd()) {
+    this.assetsDir = path.resolve(root, CACHE_DIR, ASSETS_DIR);
+  }
+  getFileHash(filePath) {
+    return crypto.createHash("md5").update(fs2.readFileSync(filePath)).digest("hex");
+  }
+  get(sourcePath, cacheKey) {
+    if (!fs2.existsSync(sourcePath)) return null;
+    const sourceHash = this.getFileHash(sourcePath);
+    const cachedPath = this.getCachedPath(
+      sourcePath,
+      `${cacheKey}-${sourceHash}`
+    );
+    return fs2.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}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+      await writeFile(tempPath, content);
+      await rename(tempPath, cachedPath);
+    });
+  }
+  getCachedPath(sourcePath, cacheKey) {
+    const ext = path.extname(sourcePath);
+    const name = path.basename(sourcePath, ext);
+    const safeKey = cacheKey.replace(/[^a-z0-9]/gi, "-").toLowerCase();
+    return path.join(this.assetsDir, `${name}.${safeKey}${ext}`);
+  }
+  clear() {
+    if (fs2.existsSync(this.assetsDir)) {
+      fs2.rmSync(this.assetsDir, { recursive: true, force: true });
+    }
+  }
+  async flush() {
+    await backgroundQueue.flush();
+  }
+};
+async function flushCache() {
+  await backgroundQueue.flush();
+}
+
+export {
+  normalizePath,
+  stripNumberPrefix,
+  extractNumberPrefix,
+  isDocFile,
+  parseFrontmatter,
+  escapeHtml,
+  fileToRoutePath,
+  capitalize,
+  FileCache,
+  TransformCache,
+  AssetCache,
+  flushCache
+};