@docubook/flame 1.4.4 → 1.5.0

package/.docu/node/preview.impl.ts

@@ -0,0 +1,96 @@
+/**
+ * Runtime-neutral preview server — mirror of `preview.ts` (Bun-only,
+ * protected) driven by a `RuntimeAdapter` and `node:fs` file reads.
+ */
+
+import { existsSync, statSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import type { RuntimeAdapter, ServerHandle } from "@docubook/runt";
+import { logger } from "./logger";
+import { DIST_DIR } from "./paths";
+import { getContentType } from "./utils";
+import { SECURITY_HEADERS, generateNonce, cspHeader, injectNonce } from "./security";
+
+function resolveFile(pathname: string): string | null {
+  const path = pathname.slice(1);
+  const isWithinDist = (p: string) => 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 as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+  }
+  return null;
+}
+
+export async function runPreview(adapter: RuntimeAdapter): Promise<ServerHandle | null> {
+  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;
+}

package/.docu/node/preview.node.ts

@@ -0,0 +1,4 @@
+import { nodeAdapter } from "@docubook/runt";
+import { runPreview } from "./preview.impl";
+
+await runPreview(nodeAdapter);

package/.docu/node/security.ts

@@ -80,6 +80,11 @@ export function isSlugSafe(slug: string, docsDir: string): boolean {
   }
 }
 
+/** Normalize an esbuild importer path to a canonical forward-slash absolute form. */
+export function normalizeImporterPath(importer: string): string {
+  return resolve(importer).replace(/\\/g, "/");
+}
+
 export function injectNonce(html: string, nonce: string): string {
   return html.replace(/<script\b(?![^>]*\bsrc\s*=)([^>]*)>/gi, (match) => {
     if (/nonce\s*=/i.test(match)) {

package/.docu/node/server-routes.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { statSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import React, { type ReactNode } from "react";
 import { renderToString } from "react-dom/server";
 import { compileMdx } from "./mdx";
@@ -14,7 +14,7 @@ import NotFoundPage from "../pages/404";
 import IndexPage from "../pages/index";
 import { DocsLayout } from "../components/DocsLayout";
 import { generateNonce, isPathSafe, isSlugSafe, htmlResponse, SECURITY_HEADERS } from "./security";
-import { htmlShell as createHtmlShell, hmrScript, errorHtml } from "./html";
+import { htmlShell as createHtmlShell, hmrScript, errorHtml } from "./html.shared";
 
 export interface ServerState {
   docuConfig: DocuConfig;
@@ -249,7 +249,7 @@ export function serveStatic(pathname: string): Response | null {
   try {
     const s = statSync(assetPath);
     if (s.isFile()) {
-      return new Response(Bun.file(assetPath), {
+      return new Response(readFileSync(assetPath), {
         headers: { "Content-Type": getContentType(pathname) },
       });
     }
@@ -266,7 +266,7 @@ export function serveStatic(pathname: string): Response | null {
     try {
       const s = statSync(docsAsset);
       if (s.isFile()) {
-        return new Response(Bun.file(docsAsset), {
+        return new Response(readFileSync(docsAsset), {
           headers: { "Content-Type": getContentType(pathname) },
         });
       }

package/.docu/node/server.deno.ts

@@ -0,0 +1,4 @@
+import { denoAdapter } from "@docubook/runt";
+import { runServer } from "./server.impl";
+
+await runServer(denoAdapter);

package/.docu/node/server.impl.ts

@@ -0,0 +1,184 @@
+/**
+ * Runtime-neutral dev server — mirror of `server.ts` (Bun-only, protected)
+ * driven by a `RuntimeAdapter` from `@docubook/runt` instead of `Bun.serve`,
+ * with manual route matching instead of `Bun.FileSystemRouter`. The page set
+ * is static (`/`, `/docs/[[...slug]]`, `/404`), so a router is unnecessary.
+ */
+
+import { watch } from "node:fs";
+import type { RuntimeAdapter, ServerHandle } from "@docubook/runt";
+import { DOCS_DIR, loadDocuConfig } from "./paths";
+import { loadPlugins } from "./plugin-loader";
+import { BuildPluginBuilder } from "./plugin-builder";
+import { buildClientBundle, computeInlineThemeCss } from "./hydrate.node";
+import { generateSearchIndex } from "./search-indexer";
+import { logger } from "./logger";
+import { initSentry, captureException } from "./sentry";
+import {
+  serveStatic,
+  handleDocsIndex,
+  handleDocsRoute,
+  handleIndex,
+  handleNotFound,
+  serverErrorResponse,
+  type ServerState,
+} from "./server-routes";
+import { wrapPluginResponse } from "./security";
+import { stripDocsHtmlSuffix } from "./utils";
+
+export async function runServer(adapter: RuntimeAdapter): Promise<ServerHandle> {
+  const docuConfig = loadDocuConfig();
+
+  const parsedPort = parseInt(process.env.PORT ?? "3000", 10);
+  const PORT =
+    Number.isInteger(parsedPort) && parsedPort > 0 && parsedPort <= 65535 ? parsedPort : 3000;
+
+  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();
+
+  // Plugin setup — all hooks active (onLoad, remark/rehype, frontmatter, head/body, html transform, handleRequest)
+  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: ServerState = {
+    docuConfig,
+    assetManifest,
+    inlineThemeCss,
+    builder,
+  };
+
+  const hmrClients = new Set<ReadableStreamDefaultController>();
+
+  let hmrTimeout: ReturnType<typeof setTimeout> | null = 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: ServerHandle | null = null;
+
+  const fetchHandler = async (req: Request): Promise<Response> => {
+    const url = new URL(req.url);
+    // Generated links carry `.html` (matching the static build output);
+    // route them to the same handler as their extensionless form.
+    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: Response;
+
+      // Manual route matching — same routes Bun.FileSystemRouter derives
+      // from `.docu/pages/` ("/", "/docs/[[...slug]]", "/404").
+      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;
+}

package/.docu/node/server.node.ts

@@ -0,0 +1,4 @@
+import { nodeAdapter } from "@docubook/runt";
+import { runServer } from "./server.impl";
+
+await runServer(nodeAdapter);

package/.docu/styles/globals.css

@@ -1,10 +1,25 @@
-@import "daisyui/daisyui.css";
-@import "@docubook/mdx-content/styles.css";
 @import "tailwindcss";
+@import "@docubook/mdx-content/styles.css";
 
+@plugin "daisyui" {
+  themes:
+    light --default,
+    dark;
+}
 @plugin "@tailwindcss/typography";
 @source "../../.docu/components";
 @source "../../.docu/pages";
+@source inline("breadcrumbs collapse collapse-open collapse-close collapse-arrow collapse-plus collapse-title collapse-content");
+@source inline("modal modal-top modal-middle modal-bottom modal-box modal-backdrop");
+@source inline("drawer drawer-end drawer-toggle drawer-side drawer-overlay drawer-content");
+@source inline("sm:drawer-open md:drawer-open lg:drawer-open xl:drawer-open");
+@source inline("navbar menu menu-horizontal");
+@source inline("kbd kbd-xs kbd-sm kbd-md kbd-lg kbd-xl");
+@source inline("toggle theme-controller toggle-xs toggle-sm toggle-md toggle-lg");
+@source inline("toggle-primary toggle-secondary toggle-accent toggle-neutral toggle-success toggle-warning toggle-info toggle-error");
+@source inline("input input-ghost input-xs input-sm input-md input-lg input-xl");
+@source inline("input-primary input-secondary input-accent input-neutral input-success input-warning input-info input-error");
+@source inline("label");
 
 @custom-variant dark (&:is(.dark *));
 
@@ -13,7 +28,7 @@
   --color-base-200: oklch(var(--base-200, 100% 0 0));
   --color-base-300: oklch(var(--base-300, 100% 0 0));
   --color-base-content: oklch(var(--base-content, 100% 0 0));
-  --color-border: hsl(var(--border));
+  --color-border: hsl(var(--border-color));
   --color-input: hsl(var(--input));
   --color-ring: hsl(var(--ring));
   --color-background: hsl(var(--background));
@@ -80,7 +95,7 @@
     --accent-foreground: 0 0% 100%;
     --destructive: 0 85% 60%;
     --destructive-foreground: 0 0% 100%;
-    --border: 210 20% 85%;
+    --border-color: 210 20% 85%;
     --input: 210 20% 85%;
     --ring: 210 81% 56%;
     --radius: 0.5rem;
@@ -107,7 +122,7 @@
     --accent-foreground: 0 0% 100%;
     --destructive: 0 80% 65%;
     --destructive-foreground: 0 0% 100%;
-    --border: 220 10% 28%;
+    --border-color: 220 10% 28%;
     --input: 220 10% 28%;
     --ring: 210 100% 67%;
     --radius: 0.5rem;