@docubook/flame 1.4.3 → 1.5.0

package/.docu/lib/chunk-654THQOR.js

@@ -0,0 +1,461 @@
+import {
+  BuildPluginBuilder,
+  DocsLayout,
+  DocsPage,
+  IndexPage,
+  NotFoundPage,
+  buildClientBundle,
+  captureException,
+  compileMdx,
+  computeInlineThemeCss,
+  generateSearchIndex,
+  getGitLastModifiedBatch,
+  htmlShell,
+  initSentry,
+  loadPlugins
+} from "./chunk-2QHMGZIL.js";
+import {
+  generateNonce,
+  scanMdxFiles
+} from "./chunk-RE4NGTMT.js";
+import {
+  logger
+} from "./chunk-HH4YXWEF.js";
+import {
+  ASSETS_DIR,
+  CACHE_FILE,
+  DIST_DIR,
+  DOCS_ASSETS_DIR,
+  DOCS_DIR,
+  PROJECT_ROOT,
+  loadDocuConfig
+} from "./chunk-J5NMYSBJ.js";
+
+// .docu/node/build.impl.ts
+import { readFile, writeFile, mkdir, readdir as readdir2, copyFile } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { createHash } from "node:crypto";
+import { join as join2, dirname } from "node:path";
+import React from "react";
+import { renderToString } from "react-dom/server";
+
+// .docu/node/build-summary.ts
+import { readdir, stat } from "node:fs/promises";
+import { join, relative, extname } from "node:path";
+import { existsSync } from "node:fs";
+var MAX_FILES_SHOWN = 10;
+var SEP = "\u2500".repeat(60);
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+async function walkFiles(dir) {
+  const out = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await walkFiles(full));
+    } else if (entry.isFile()) {
+      const s = await stat(full);
+      out.push({ path: full, size: s.size });
+    }
+  }
+  return out;
+}
+async function collectBuildOutput(distDir) {
+  if (!existsSync(distDir)) return null;
+  const all = await walkFiles(distDir);
+  if (all.length === 0) return null;
+  const files = all.map((f) => ({ path: relative(distDir, f.path), size: f.size })).sort((a, b) => b.size !== a.size ? b.size - a.size : a.path.localeCompare(b.path));
+  const byExt = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const ext = extname(f.path) || "(none)";
+    const entry = byExt.get(ext) ?? { ext, count: 0, size: 0 };
+    entry.count++;
+    entry.size += f.size;
+    byExt.set(ext, entry);
+  }
+  const byType = [...byExt.values()].sort(
+    (a, b) => b.size !== a.size ? b.size - a.size : b.count - a.count
+  );
+  return {
+    files,
+    byType,
+    totalFiles: files.length,
+    totalSize: files.reduce((sum, f) => sum + f.size, 0)
+  };
+}
+function formatBuildSummary(output) {
+  const lines = [];
+  lines.push("\u{1F4E6} Build Output Summary:");
+  lines.push(SEP);
+  const shown = output.files.slice(0, MAX_FILES_SHOWN);
+  const nameWidth = Math.min(Math.max(...shown.map((f) => f.path.length), 1), 50);
+  for (const f of shown) {
+    lines.push(`  ${f.path.padEnd(nameWidth)}  ${formatSize(f.size).padStart(10)}`);
+  }
+  const remaining = output.totalFiles - shown.length;
+  if (remaining > 0) {
+    lines.push(`  ... and ${remaining} more file${remaining === 1 ? "" : "s"}`);
+  }
+  lines.push(SEP);
+  lines.push("\u{1F4CA} Summary by Type:");
+  const extWidth = Math.max(...output.byType.map((t) => t.ext.length), 1);
+  for (const t of output.byType) {
+    const plural = t.count === 1 ? "file" : "files";
+    lines.push(
+      `  ${t.ext.padEnd(extWidth)}   ${String(t.count).padStart(3)} ${plural}   ${formatSize(
+        t.size
+      ).padStart(10)}`
+    );
+  }
+  lines.push(SEP);
+  const totalPlural = output.totalFiles === 1 ? "file" : "files";
+  lines.push(
+    `\u{1F4C8} Total: ${output.totalFiles} ${totalPlural}   ${formatSize(output.totalSize).padStart(10)}`
+  );
+  lines.push(SEP);
+  return lines.join("\n");
+}
+async function generateBuildSummary(distDir) {
+  const output = await collectBuildOutput(distDir);
+  return output ? formatBuildSummary(output) : null;
+}
+
+// .docu/node/build.impl.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  return {
+    force: args.includes("--force") || args.includes("-f"),
+    clean: args.includes("--clean") || args.includes("-c")
+  };
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+async function readCache() {
+  try {
+    if (existsSync2(CACHE_FILE)) {
+      const data = await readFile(CACHE_FILE, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (err) {
+    console.error("Failed to load build cache:", err.message);
+  }
+  return {};
+}
+async function writeCache(cache) {
+  await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2));
+}
+function parseConcurrency() {
+  return Math.max(1, parseInt(process.env.BUILD_CONCURRENCY || "4", 10) || 4);
+}
+function shouldRebuild(path, mtime, cache) {
+  const cached = cache[path];
+  if (!cached) return "yes";
+  if (mtime > cached.builtAt) return "hash_check";
+  return "no";
+}
+var assetManifest = { js: "client.js", css: "client.css" };
+var inlineThemeCss;
+async function renderDocsPage(docuConfig, slug, rawMdx, filePath, gitDates, builder, nonce) {
+  let content = rawMdx;
+  if (builder) {
+    const transformed = await builder.runOnLoad(filePath, content);
+    if (transformed?.contents) {
+      content = transformed.contents;
+    }
+  }
+  let result;
+  try {
+    const remarkPlugins = builder?.collectRemarkPlugins();
+    const rehypePlugins = builder?.collectRehypePlugins();
+    result = await compileMdx(content, filePath, gitDates, remarkPlugins, rehypePlugins);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown MDX error";
+    throw new Error(`MDX Error in: docs/${slug}.mdx
+${msg}`, { cause: err });
+  }
+  let frontmatter = result.frontmatter;
+  if (builder) {
+    frontmatter = await builder.runTransformFrontmatterChain(frontmatter, {
+      slug,
+      filePath,
+      content
+    });
+  }
+  const title = (typeof frontmatter.title === "string" ? frontmatter.title : "") || slug || "Docs";
+  const description = typeof frontmatter.description === "string" ? frontmatter.description : "";
+  const slugParts = slug ? slug.split("/") : [];
+  const page = React.createElement(
+    DocsLayout,
+    { repoUrl: docuConfig.repo?.url },
+    React.createElement(DocsPage, {
+      slug: slugParts,
+      title,
+      description,
+      date: frontmatter.date || void 0,
+      content: result.content,
+      tocs: result.tocs,
+      filePath,
+      repoUrl: docuConfig.repo?.url,
+      compiledSource: result.compiledSource
+    })
+  );
+  const body = renderToString(page);
+  const ctx = { slug, filePath, frontmatter, content, config: docuConfig };
+  const headExtra = builder?.collectHead(ctx);
+  const bodyExtra = builder?.collectBody(ctx);
+  const depth = slug ? slug.split("/").length : 1;
+  const favicon = docuConfig.meta?.favicon || "/docs/assets/images/favicon.ico";
+  let html = htmlShell({
+    title,
+    description,
+    body,
+    favicon,
+    css: assetManifest.css,
+    js: assetManifest.js,
+    nonce,
+    themeCss: inlineThemeCss,
+    depth,
+    headExtra,
+    bodyExtra
+  });
+  if (builder) {
+    html = await builder.runTransformHtmlChain(html, ctx);
+  }
+  return html;
+}
+async function copyDirectoryRecursive(src, dest) {
+  if (!existsSync2(src)) return;
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir2(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join2(src, entry.name);
+    const destPath = join2(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectoryRecursive(srcPath, destPath);
+    } else {
+      await copyFile(srcPath, destPath);
+    }
+  }
+}
+async function runBuild() {
+  const docuConfig = loadDocuConfig();
+  const args = parseArgs();
+  logger.buildStart();
+  if (args.clean) {
+    const { rm } = await import("node:fs/promises");
+    try {
+      await rm(DIST_DIR, { recursive: true, force: true });
+    } catch (err) {
+      console.error("Failed to clean dist directory:", err.message);
+    }
+  }
+  await mkdir(DIST_DIR, { recursive: true });
+  await mkdir(ASSETS_DIR, { recursive: true });
+  await copyDirectoryRecursive(DOCS_ASSETS_DIR, join2(DIST_DIR, "docs", "assets"));
+  const mdxFiles = await scanMdxFiles(DOCS_DIR);
+  const cache = args.force ? {} : await readCache();
+  let built = 0;
+  let skipped = 0;
+  logger.bundleStart();
+  let t = performance.now();
+  assetManifest = await buildClientBundle();
+  logger.bundleDone(Math.round(performance.now() - t));
+  inlineThemeCss = computeInlineThemeCss();
+  const lastManifest = cache["__assets__"];
+  const assetsChanged = !lastManifest || lastManifest.hash !== `${assetManifest.js}:${assetManifest.css}`;
+  if (assetsChanged) {
+    cache["__assets__"] = {
+      hash: `${assetManifest.js}:${assetManifest.css}`,
+      mtime: 0,
+      builtAt: Date.now()
+    };
+  }
+  const pluginsConfig = docuConfig.plugins ?? [];
+  const builder = pluginsConfig.length > 0 ? new BuildPluginBuilder(docuConfig) : null;
+  if (builder) {
+    const plugins = await loadPlugins(pluginsConfig);
+    for (const plugin of plugins) {
+      await plugin.setup(builder);
+    }
+    await builder.runOnStart();
+  }
+  logger.spinner.start("Building pages...");
+  t = performance.now();
+  const allRelPaths = mdxFiles.map((f) => f.absPath.replace(PROJECT_ROOT + "/", ""));
+  const indexMdxFull = join2(DOCS_DIR, "index.mdx");
+  if (existsSync2(indexMdxFull)) {
+    allRelPaths.push(indexMdxFull.replace(PROJECT_ROOT + "/", ""));
+  }
+  const gitDates = await getGitLastModifiedBatch(allRelPaths);
+  const CONCURRENCY = parseConcurrency();
+  const buildTasks = [];
+  const errors = [];
+  for (const file of mdxFiles) {
+    const rebuildDecision = shouldRebuild(file.path, file.mtime, cache);
+    if (rebuildDecision === "no") {
+      const outputPath = join2(DIST_DIR, "docs", `${file.path}.html`);
+      if (existsSync2(outputPath) && !assetsChanged) {
+        skipped++;
+        continue;
+      }
+    }
+    let rawMdx;
+    try {
+      rawMdx = await readFile(file.absPath, "utf-8");
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+      continue;
+    }
+    if (rebuildDecision === "hash_check") {
+      const contentHash = hashContent(rawMdx);
+      const cached = cache[file.path];
+      if (cached && cached.hash === contentHash) {
+        if (!assetsChanged) {
+          const outputPath = join2(DIST_DIR, "docs", `${file.path}.html`);
+          if (existsSync2(outputPath)) {
+            cache[file.path] = { ...cached, mtime: file.mtime, builtAt: Date.now() };
+            skipped++;
+            continue;
+          }
+        }
+      }
+    }
+    const relPath = file.absPath.replace(PROJECT_ROOT + "/", "");
+    const capturedRawMdx = rawMdx;
+    const capturedFile = file;
+    buildTasks.push(async () => {
+      try {
+        const pageNonce = generateNonce();
+        const html = await renderDocsPage(
+          docuConfig,
+          capturedFile.path,
+          capturedRawMdx,
+          relPath,
+          gitDates,
+          builder,
+          pageNonce
+        );
+        const outputPath = join2(DIST_DIR, "docs", `${capturedFile.path}.html`);
+        await mkdir(dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, html);
+        cache[capturedFile.path] = {
+          hash: hashContent(capturedRawMdx),
+          mtime: capturedFile.mtime,
+          builtAt: Date.now()
+        };
+        built++;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        errors.push(msg);
+        console.error(`
+\u274C ${msg}
+`);
+      }
+    });
+  }
+  for (let i = 0; i < buildTasks.length; i += CONCURRENCY) {
+    await Promise.all(buildTasks.slice(i, i + CONCURRENCY).map((fn) => fn()));
+  }
+  try {
+    const indexMdxPath = join2(DOCS_DIR, "index.mdx");
+    const indexRaw = await readFile(indexMdxPath, "utf-8");
+    const indexRelPath = indexMdxPath.replace(PROJECT_ROOT + "/", "");
+    const indexHtml = await renderDocsPage(
+      docuConfig,
+      "",
+      indexRaw,
+      indexRelPath,
+      gitDates,
+      builder,
+      generateNonce()
+    );
+    await mkdir(join2(DIST_DIR, "docs"), { recursive: true });
+    await writeFile(join2(DIST_DIR, "docs", "index.html"), indexHtml);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    errors.push(`index.mdx: ${msg}`);
+    console.error(`
+\u274C Failed to build index: ${msg}
+`);
+  }
+  const landingPage = React.createElement(IndexPage);
+  const landingFavicon = docuConfig.meta?.favicon || "/docs/assets/images/favicon.ico";
+  const landingHtml = htmlShell({
+    title: docuConfig.meta?.title || "DocuBook",
+    description: docuConfig.meta?.description || "",
+    body: renderToString(landingPage),
+    favicon: landingFavicon,
+    css: assetManifest.css,
+    js: assetManifest.js,
+    nonce: generateNonce(),
+    themeCss: inlineThemeCss
+  });
+  await writeFile(join2(DIST_DIR, "index.html"), landingHtml);
+  const notFoundPage = React.createElement(
+    DocsLayout,
+    { repoUrl: docuConfig.repo?.url },
+    React.createElement(NotFoundPage)
+  );
+  const notFoundFavicon = docuConfig.meta?.favicon || "/docs/assets/images/favicon.ico";
+  const notFoundHtml = htmlShell({
+    title: "404 - Not Found",
+    description: "",
+    body: renderToString(notFoundPage),
+    favicon: notFoundFavicon,
+    css: assetManifest.css,
+    js: assetManifest.js,
+    nonce: generateNonce(),
+    themeCss: inlineThemeCss
+  });
+  await writeFile(join2(DIST_DIR, "404.html"), notFoundHtml);
+  logger.spinner.stop(
+    `Built ${built} pages (${skipped} cached) \x1B[90m(${Math.round(performance.now() - t)}ms)\x1B[0m`
+  );
+  if (builder) {
+    const pages = mdxFiles.map((f) => ({
+      slug: f.path,
+      title: f.path.split("/").pop() || f.path,
+      filePath: join2(DOCS_DIR, f.path),
+      outputPath: join2(DIST_DIR, "docs", `${f.path}.html`)
+    }));
+    await builder.runOnEnd(pages);
+  }
+  logger.indexStart();
+  t = performance.now();
+  const indexCount = await generateSearchIndex();
+  logger.indexDone(indexCount, Math.round(performance.now() - t));
+  logger.routes();
+  console.log("");
+  const buildSummary = await generateBuildSummary(DIST_DIR);
+  if (buildSummary) {
+    console.log(buildSummary);
+    console.log("");
+  }
+  await writeCache(cache);
+  if (errors.length > 0) {
+    console.error(`
+\u274C Build completed with ${errors.length} error(s)
+`);
+    process.exit(1);
+  }
+}
+async function runBuildCli() {
+  try {
+    await initSentry();
+    await runBuild();
+  } catch (err) {
+    captureException(err);
+    console.error("Build failed:", err);
+    process.exit(1);
+  }
+}
+
+export {
+  runBuild,
+  runBuildCli
+};

package/.docu/lib/chunk-C6RZ2KBH.js

@@ -0,0 +1,79 @@
+import {
+  DIST_DIR,
+  PROJECT_ROOT
+} from "./chunk-J5NMYSBJ.js";
+
+// .docu/node/deploy.shared.ts
+import { writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var WORKFLOW_DIR = join(PROJECT_ROOT, ".github/workflows");
+var WORKFLOW_FILE = join(WORKFLOW_DIR, "deploy.yml");
+async function runDeploy() {
+  console.log("\u{1F4E6} Building for production...\n");
+  process.env.NODE_ENV = "production";
+  const { runBuildCli } = await import("./build.impl-ST63VRTV.js");
+  await runBuildCli();
+  await writeFile(join(DIST_DIR, ".nojekyll"), "");
+  if (!existsSync(WORKFLOW_FILE)) {
+    await mkdir(WORKFLOW_DIR, { recursive: true });
+    await writeFile(WORKFLOW_FILE, GITHUB_ACTIONS_WORKFLOW);
+    console.log("\n\u{1F4C4} Created .github/workflows/deploy.yml");
+  }
+  console.log("\n\u2705 Ready to deploy!");
+  console.log("   Output: .docu/dist/");
+  console.log("   Push to GitHub and enable Pages (Settings \u2192 Pages \u2192 Source: GitHub Actions)");
+}
+var GITHUB_ACTIONS_WORKFLOW = `name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - run: npm install
+
+      - run: npm run build
+
+      - name: Add .nojekyll
+        run: touch .docu/dist/.nojekyll
+
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: .docu/dist
+
+  deploy:
+    environment:
+      name: github-pages
+      url: \${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4
+`;
+
+export {
+  runDeploy
+};