@docubook/flame 1.4.4 → 1.5.1

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

@@ -0,0 +1,368 @@
+import {
+  BuildPluginBuilder,
+  DocsLayout,
+  DocsPage,
+  IndexPage,
+  NotFoundPage,
+  buildClientBundle,
+  captureException,
+  compileMdx,
+  computeInlineThemeCss,
+  generateSearchIndex,
+  getGitLastModifiedBatch,
+  htmlShell,
+  initSentry,
+  loadPlugins
+} from "./chunk-AI7QAMMZ.js";
+import {
+  generateNonce,
+  scanMdxFiles
+} from "./chunk-RE4NGTMT.js";
+import {
+  logger
+} from "./chunk-PTRZ2S2C.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, copyFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join, dirname } from "node:path";
+import React from "react";
+import { renderToString } from "react-dom/server";
+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 (existsSync(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 (!existsSync(src)) return;
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(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, join(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 = join(DOCS_DIR, "index.mdx");
+  if (existsSync(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 = join(DIST_DIR, "docs", `${file.path}.html`);
+      if (existsSync(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 = join(DIST_DIR, "docs", `${file.path}.html`);
+          if (existsSync(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 = join(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 = join(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(join(DIST_DIR, "docs"), { recursive: true });
+    await writeFile(join(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(join(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(join(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: join(DOCS_DIR, f.path),
+      outputPath: join(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();
+  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-IR5TVJOV.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-7KJ4ZTAJ.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
+};

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

@@ -0,0 +1,59 @@
+// .docu/node/paths.ts
+import { resolve, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { readdir, rm, unlink } from "node:fs/promises";
+var FRAMEWORK_ROOT = resolve(import.meta.dirname, "../..");
+var PROJECT_ROOT = process.cwd();
+var PAGES_DIR = join(FRAMEWORK_ROOT, ".docu/pages");
+var STYLES_DIR = join(FRAMEWORK_ROOT, ".docu/styles");
+var nodeDir = join(FRAMEWORK_ROOT, ".docu/node");
+var libDir = join(FRAMEWORK_ROOT, ".docu/lib");
+var LIB_DIR = existsSync(nodeDir) ? nodeDir : libDir;
+var DIST_DIR = join(PROJECT_ROOT, ".docu/dist");
+var ASSETS_DIR = join(DIST_DIR, "assets");
+var CACHE_FILE = join(PROJECT_ROOT, ".docu/build-cache.json");
+var DOCS_DIR = join(PROJECT_ROOT, "docs");
+var DOCS_ASSETS_DIR = join(PROJECT_ROOT, "docs/assets");
+var DOCU_CONFIG_PATH = join(PROJECT_ROOT, "docu.json");
+var _config = null;
+async function cleanOldBundles() {
+  try {
+    const files = await readdir(ASSETS_DIR);
+    for (const file of files) {
+      if (file.startsWith("client.") || file.startsWith("client-")) {
+        await unlink(join(ASSETS_DIR, file));
+      }
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      console.error("Failed to clean old bundles:", err.message);
+    }
+  }
+  try {
+    await rm(join(ASSETS_DIR, "chunks"), { recursive: true, force: true });
+  } catch (err) {
+    console.error("Failed to clean old chunks:", err.message);
+  }
+}
+function loadDocuConfig() {
+  if (_config) return _config;
+  if (!existsSync(DOCU_CONFIG_PATH)) {
+    throw new Error(`docu.json not found at ${DOCU_CONFIG_PATH}`);
+  }
+  _config = JSON.parse(readFileSync(DOCU_CONFIG_PATH, "utf-8"));
+  return _config;
+}
+
+export {
+  FRAMEWORK_ROOT,
+  PROJECT_ROOT,
+  STYLES_DIR,
+  LIB_DIR,
+  DIST_DIR,
+  ASSETS_DIR,
+  CACHE_FILE,
+  DOCS_DIR,
+  DOCS_ASSETS_DIR,
+  cleanOldBundles,
+  loadDocuConfig
+};