@docubook/flame 1.4.4 → 1.5.0

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

@@ -0,0 +1,383 @@
+import {
+  BuildPluginBuilder,
+  DocsLayout,
+  DocsPage,
+  IndexPage,
+  NotFoundPage,
+  buildClientBundle,
+  captureException,
+  compileMdx,
+  computeInlineThemeCss,
+  errorHtml,
+  generateSearchIndex,
+  hmrScript,
+  htmlShell,
+  initSentry,
+  loadPlugins
+} from "./chunk-2QHMGZIL.js";
+import {
+  SECURITY_HEADERS,
+  generateNonce,
+  getContentType,
+  htmlResponse,
+  isPathSafe,
+  isSlugSafe,
+  stripDocsHtmlSuffix,
+  wrapPluginResponse
+} from "./chunk-RE4NGTMT.js";
+import {
+  logger
+} from "./chunk-HH4YXWEF.js";
+import {
+  DIST_DIR,
+  DOCS_DIR,
+  PROJECT_ROOT,
+  loadDocuConfig
+} from "./chunk-J5NMYSBJ.js";
+
+// .docu/node/server.impl.ts
+import { watch } from "node:fs";
+
+// .docu/node/server-routes.ts
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { readFileSync, statSync } from "node:fs";
+import React from "react";
+import { renderToString } from "react-dom/server";
+function createHtmlResponse(title, description, body, status, state, depth = 0) {
+  const nonce = generateNonce();
+  const favicon = state.docuConfig.meta?.favicon || "/favicon.ico";
+  const html = htmlShell({
+    title,
+    description,
+    body,
+    favicon,
+    css: state.assetManifest.css,
+    js: state.assetManifest.js,
+    nonce,
+    extraScripts: hmrScript(nonce),
+    themeCss: state.inlineThemeCss,
+    depth
+  });
+  return htmlResponse(html, nonce, status, process.env.NODE_ENV !== "production");
+}
+async function getDocsForSlug(slug, state) {
+  if (!isSlugSafe(slug, DOCS_DIR)) return null;
+  const paths = [
+    resolve(DOCS_DIR, slug, "index.mdx"),
+    resolve(DOCS_DIR, `${slug}.mdx`),
+    resolve(DOCS_DIR, slug, "index.md"),
+    resolve(DOCS_DIR, `${slug}.md`)
+  ];
+  const resolvedDocsDir = resolve(DOCS_DIR);
+  let filePath = null;
+  let raw = null;
+  for (const p of paths) {
+    const resolvedCandidate = resolve(p);
+    if (resolvedCandidate !== resolvedDocsDir && !resolvedCandidate.startsWith(resolvedDocsDir + "/")) {
+      continue;
+    }
+    try {
+      raw = await readFile(resolvedCandidate, "utf-8");
+      filePath = resolvedCandidate;
+      break;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  if (!filePath || !raw) return null;
+  const relPath = filePath.replace(PROJECT_ROOT + "/", "");
+  let content = raw;
+  if (state.builder) {
+    const transformed = await state.builder.runOnLoad(relPath, content);
+    if (transformed?.contents) {
+      content = transformed.contents;
+    }
+  }
+  const remarkPlugins = state.builder?.collectRemarkPlugins();
+  const rehypePlugins = state.builder?.collectRehypePlugins();
+  const result = await compileMdx(content, relPath, void 0, remarkPlugins, rehypePlugins);
+  let frontmatter = result.frontmatter;
+  if (state.builder) {
+    frontmatter = await state.builder.runTransformFrontmatterChain(frontmatter, {
+      slug: slug || "/",
+      filePath: relPath,
+      content
+    });
+  }
+  return {
+    content: result.content,
+    compiledSource: result.compiledSource,
+    frontmatter,
+    tocs: result.tocs,
+    filePath: relPath,
+    resolvedContent: content
+  };
+}
+async function renderDocsServerPage(doc, slug, pathname, state) {
+  const title = (typeof doc.frontmatter.title === "string" ? doc.frontmatter.title : "") || slug.join("/") || "Docs";
+  const description = typeof doc.frontmatter.description === "string" ? doc.frontmatter.description : "";
+  const page = React.createElement(
+    DocsLayout,
+    { repoUrl: state.docuConfig.repo?.url, pathname },
+    React.createElement(DocsPage, {
+      slug,
+      title,
+      description,
+      date: doc.frontmatter.date,
+      content: doc.content,
+      tocs: doc.tocs,
+      filePath: doc.filePath,
+      repoUrl: state.docuConfig.repo?.url,
+      compiledSource: doc.compiledSource
+    })
+  );
+  const body = renderToString(page);
+  const depth = slug.length || 1;
+  if (state.builder) {
+    const ctx = {
+      slug: slug.join("/") || "/",
+      filePath: doc.filePath,
+      frontmatter: doc.frontmatter,
+      content: doc.resolvedContent,
+      config: state.docuConfig
+    };
+    const headExtra = state.builder.collectHead(ctx);
+    const bodyExtra = state.builder.collectBody(ctx);
+    const nonce = generateNonce();
+    const favicon = state.docuConfig.meta?.favicon || "/favicon.ico";
+    let html = htmlShell({
+      title,
+      description,
+      body,
+      favicon,
+      css: state.assetManifest.css,
+      js: state.assetManifest.js,
+      nonce,
+      extraScripts: hmrScript(nonce),
+      themeCss: state.inlineThemeCss,
+      headExtra,
+      bodyExtra,
+      depth
+    });
+    html = await state.builder.runTransformHtmlChain(html, ctx);
+    return htmlResponse(html, nonce, 200, process.env.NODE_ENV !== "production");
+  }
+  return createHtmlResponse(title, description, body, 200, state, depth);
+}
+function renderPage(Component, title, description, status, state, props = {}, depth = 0) {
+  const page = React.createElement(
+    DocsLayout,
+    { repoUrl: state.docuConfig.repo?.url, pathname: "/docs" },
+    React.createElement(Component, props)
+  );
+  const body = renderToString(page);
+  return createHtmlResponse(title, description, body, status, state, depth);
+}
+async function handleDocsIndex(state) {
+  const doc = await getDocsForSlug("", state);
+  if (!doc) return renderPage(NotFoundPage, "404 - Not Found", "", 404, state, {}, 1);
+  return renderDocsServerPage(doc, [], "/docs", state);
+}
+async function handleDocsRoute(slug, state) {
+  const path = slug.join("/");
+  const doc = await getDocsForSlug(path, state);
+  if (!doc)
+    return renderPage(NotFoundPage, "404 - Not Found", "", 404, state, {}, slug.length || 1);
+  return renderDocsServerPage(doc, slug, `/docs/${path}`, state);
+}
+function handleIndex(state) {
+  const page = React.createElement(IndexPage);
+  const body = renderToString(page);
+  return createHtmlResponse(
+    state.docuConfig.meta?.title || "DocuBook",
+    state.docuConfig.meta?.description || "",
+    body,
+    200,
+    state
+  );
+}
+function handleNotFound(state, depth = 0) {
+  return renderPage(NotFoundPage, "404 - Not Found", "", 404, state, {}, depth);
+}
+function serveStatic(pathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+  if (!isPathSafe(pathname, DIST_DIR)) return null;
+  const assetPath = resolve(DIST_DIR, decoded.slice(1));
+  try {
+    const s = statSync(assetPath);
+    if (s.isFile()) {
+      return new Response(readFileSync(assetPath), {
+        headers: { "Content-Type": getContentType(pathname) }
+      });
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  if (decoded.startsWith("/docs/assets/")) {
+    const docsAssetsDir = resolve(DOCS_DIR, "assets");
+    const requestedRelative = decoded.slice("/docs/assets/".length);
+    const docsAsset = resolve(docsAssetsDir, requestedRelative);
+    const docsAssetsDirWithSep = docsAssetsDir.endsWith("/") ? docsAssetsDir : docsAssetsDir + "/";
+    if (docsAsset !== docsAssetsDir && !docsAsset.startsWith(docsAssetsDirWithSep)) return null;
+    try {
+      const s = statSync(docsAsset);
+      if (s.isFile()) {
+        return new Response(readFileSync(docsAsset), {
+          headers: { "Content-Type": getContentType(pathname) }
+        });
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  return null;
+}
+function serverErrorResponse(error) {
+  const msg = error instanceof Error ? error.message : "Unknown error";
+  const st = error instanceof Error ? error.stack : void 0;
+  return new Response(errorHtml(msg, st), {
+    status: 500,
+    headers: {
+      "Content-Type": "text/html",
+      ...SECURITY_HEADERS,
+      "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'"
+    }
+  });
+}
+
+// .docu/node/server.impl.ts
+async function runServer(adapter) {
+  const docuConfig = loadDocuConfig();
+  const parsedPort = parseInt(process.env.PORT ?? "3000", 10);
+  const PORT = Number.isInteger(parsedPort) && parsedPort > 0 && parsedPort <= 65535 ? parsedPort : 3e3;
+  logger.buildStart();
+  await initSentry();
+  logger.bundleStart();
+  let t = performance.now();
+  const assetManifest = await buildClientBundle();
+  logger.bundleDone(Math.round(performance.now() - t));
+  const inlineThemeCss = computeInlineThemeCss();
+  logger.indexStart();
+  t = performance.now();
+  const records = await generateSearchIndex();
+  logger.indexDone(records, Math.round(performance.now() - t));
+  logger.routes();
+  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);
+    }
+  }
+  const state = {
+    docuConfig,
+    assetManifest,
+    inlineThemeCss,
+    builder
+  };
+  const hmrClients = /* @__PURE__ */ new Set();
+  let hmrTimeout = null;
+  const watcher = watch(DOCS_DIR, { recursive: true }, (_event, filename) => {
+    if (!filename || !filename.endsWith(".mdx") && !filename.endsWith(".md")) return;
+    if (hmrTimeout) clearTimeout(hmrTimeout);
+    hmrTimeout = setTimeout(() => {
+      for (const client of [...hmrClients]) {
+        try {
+          client.enqueue(new TextEncoder().encode("data: reload\n\n"));
+        } catch {
+          hmrClients.delete(client);
+        }
+      }
+    }, 300);
+  });
+  process.on("SIGINT", () => {
+    watcher.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    watcher.close();
+    process.exit(0);
+  });
+  let handle = null;
+  const fetchHandler = async (req) => {
+    const url = new URL(req.url);
+    const pathname = stripDocsHtmlSuffix(url.pathname);
+    const startTime = performance.now();
+    if (builder) {
+      const pluginResponse = await builder.runHandleRequest(req, {
+        port: handle?.port ?? PORT,
+        hostname: handle?.hostname ?? "localhost"
+      });
+      if (pluginResponse) {
+        const securedResponse = wrapPluginResponse(pluginResponse, true);
+        logger.request(
+          req.method,
+          pathname,
+          securedResponse.status,
+          Math.round(performance.now() - startTime)
+        );
+        return securedResponse;
+      }
+    }
+    try {
+      if (pathname === "/__hmr") {
+        const stream = new ReadableStream({
+          start(controller) {
+            hmrClients.add(controller);
+            controller.enqueue(new TextEncoder().encode("data: connected\n\n"));
+          },
+          cancel(controller) {
+            hmrClients.delete(controller);
+          }
+        });
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          }
+        });
+      }
+      if (pathname.startsWith("/assets/") || /\.\w+$/.test(pathname)) {
+        const staticRes = serveStatic(pathname);
+        if (staticRes) return staticRes;
+      }
+      let response;
+      if (pathname === "/") {
+        response = handleIndex(state);
+      } else if (pathname === "/docs" || pathname === "/docs/") {
+        response = await handleDocsIndex(state);
+      } else if (pathname.startsWith("/docs/")) {
+        const slug = pathname.slice("/docs/".length).split("/").filter(Boolean);
+        response = slug.length === 0 ? await handleDocsIndex(state) : await handleDocsRoute(slug, state);
+      } else {
+        response = handleNotFound(state);
+      }
+      logger.request(
+        req.method,
+        pathname,
+        response.status,
+        Math.round(performance.now() - startTime)
+      );
+      return response;
+    } catch (err) {
+      captureException(err, { method: req.method, pathname });
+      logger.request(req.method, pathname, 500, Math.round(performance.now() - startTime));
+      return serverErrorResponse(err);
+    }
+  };
+  handle = await adapter.serve(fetchHandler, { port: PORT, idleTimeout: 255 });
+  logger.ready(handle.port, true);
+  return handle;
+}
+
+export {
+  runServer
+};

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

@@ -0,0 +1,92 @@
+import {
+  SECURITY_HEADERS,
+  cspHeader,
+  generateNonce,
+  getContentType,
+  injectNonce
+} from "./chunk-RE4NGTMT.js";
+import {
+  logger
+} from "./chunk-HH4YXWEF.js";
+import {
+  DIST_DIR
+} from "./chunk-J5NMYSBJ.js";
+
+// .docu/node/preview.impl.ts
+import { existsSync, statSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+function resolveFile(pathname) {
+  const path = pathname.slice(1);
+  const isWithinDist = (p) => p === DIST_DIR || p.startsWith(DIST_DIR + "/");
+  if (!path.includes(".")) {
+    const withIndex = resolve(DIST_DIR, path, "index.html");
+    if (isWithinDist(withIndex) && existsSync(withIndex)) return withIndex;
+    const withHtml = resolve(DIST_DIR, path + ".html");
+    if (isWithinDist(withHtml) && existsSync(withHtml)) return withHtml;
+  }
+  const exact = resolve(DIST_DIR, path);
+  if (!isWithinDist(exact)) return null;
+  try {
+    if (statSync(exact).isFile()) return exact;
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  return null;
+}
+async function runPreview(adapter) {
+  const PORT = parseInt(process.env.PORT || "4173", 10);
+  logger.buildStart();
+  if (!existsSync(DIST_DIR)) {
+    logger.spinner.start("Checking build output...");
+    logger.spinner.info("dist not found. Run \x1B[1mflame build\x1B[0m first.");
+    process.exit(0);
+  }
+  const notFoundPath = resolve(DIST_DIR, "404.html");
+  const handle = await adapter.serve(
+    async (req) => {
+      const url = new URL(req.url);
+      const pathname = decodeURIComponent(url.pathname);
+      const filePath = resolveFile(pathname);
+      if (filePath) {
+        const contentType = getContentType(filePath);
+        if (contentType === "text/html") {
+          const nonce = generateNonce();
+          const html = await readFile(filePath, "utf-8");
+          const modified = injectNonce(html, nonce);
+          return new Response(modified, {
+            headers: {
+              "Content-Type": "text/html",
+              ...SECURITY_HEADERS,
+              "Content-Security-Policy": cspHeader(nonce, true)
+            }
+          });
+        }
+        return new Response(readFileSync(filePath), {
+          headers: { "Content-Type": contentType }
+        });
+      }
+      if (existsSync(notFoundPath)) {
+        const nonce = generateNonce();
+        const html = await readFile(notFoundPath, "utf-8");
+        const modified = injectNonce(html, nonce);
+        return new Response(modified, {
+          status: 404,
+          headers: {
+            "Content-Type": "text/html",
+            ...SECURITY_HEADERS,
+            "Content-Security-Policy": cspHeader(nonce, true)
+          }
+        });
+      }
+      return new Response("404 - Not Found", { status: 404 });
+    },
+    { port: PORT }
+  );
+  logger.ready(handle.port);
+  return handle;
+}
+
+export {
+  runPreview
+};

package/.docu/lib/clean.js

@@ -0,0 +1,32 @@
+import {
+  logger
+} from "./chunk-HH4YXWEF.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/clean.ts
+import { rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+var DIST = ".docu/dist";
+var CACHE = ".docu/build-cache.json";
+async function clean() {
+  logger.buildStart();
+  logger.spinner.start("Cleaning build artifacts...");
+  let removed = 0;
+  if (existsSync(DIST)) {
+    await rm(DIST, { recursive: true, force: true });
+    removed++;
+  }
+  if (existsSync(CACHE)) {
+    await rm(CACHE, { force: true });
+    removed++;
+  }
+  if (removed === 0) {
+    logger.spinner.info("Nothing to clean");
+  } else {
+    logger.spinner.stop(`Cleaned ${removed} item(s)`);
+  }
+}
+clean().catch((err) => {
+  console.error("Clean failed:", err);
+  process.exit(1);
+});

package/.docu/lib/deploy.deno.js

@@ -0,0 +1,13 @@
+import {
+  runDeploy
+} from "./chunk-C6RZ2KBH.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/deploy.deno.ts
+try {
+  await runDeploy();
+} catch (err) {
+  console.error("Deploy failed:", err);
+  process.exit(1);
+}
+process.exit(0);

package/.docu/lib/deploy.node.js

@@ -0,0 +1,10 @@
+import {
+  runDeploy
+} from "./chunk-C6RZ2KBH.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/deploy.node.ts
+runDeploy().catch((err) => {
+  console.error("Deploy failed:", err);
+  process.exit(1);
+});

package/.docu/lib/preview.deno.js

@@ -0,0 +1,10 @@
+import {
+  runPreview
+} from "./chunk-ZOWTASXL.js";
+import "./chunk-RE4NGTMT.js";
+import "./chunk-HH4YXWEF.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/preview.deno.ts
+import { denoAdapter } from "@docubook/runt";
+await runPreview(denoAdapter);

package/.docu/lib/preview.node.js

@@ -0,0 +1,10 @@
+import {
+  runPreview
+} from "./chunk-ZOWTASXL.js";
+import "./chunk-RE4NGTMT.js";
+import "./chunk-HH4YXWEF.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/preview.node.ts
+import { nodeAdapter } from "@docubook/runt";
+await runPreview(nodeAdapter);

package/.docu/lib/server.deno.js

@@ -0,0 +1,11 @@
+import {
+  runServer
+} from "./chunk-X6GYOIYZ.js";
+import "./chunk-2QHMGZIL.js";
+import "./chunk-RE4NGTMT.js";
+import "./chunk-HH4YXWEF.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/server.deno.ts
+import { denoAdapter } from "@docubook/runt";
+await runServer(denoAdapter);

package/.docu/lib/server.node.js

@@ -0,0 +1,11 @@
+import {
+  runServer
+} from "./chunk-X6GYOIYZ.js";
+import "./chunk-2QHMGZIL.js";
+import "./chunk-RE4NGTMT.js";
+import "./chunk-HH4YXWEF.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/server.node.ts
+import { nodeAdapter } from "@docubook/runt";
+await runServer(nodeAdapter);