sibujs 4.13.0 → 4.14.0

package/dist/prerenderServer-MXJEVWA3.js

@@ -0,0 +1,350 @@
+import "./chunk-R5U7XKVJ.js";
+
+// src/build/prerenderServer.ts
+var DRIVER_ID = "virtual:sibu-prerender-driver";
+var DRIVER_RESOLVED = `\0${DRIVER_ID}`;
+function joinPath(parent, child) {
+  if (child === "*" || child.startsWith("/*")) return child;
+  const p = parent.replace(/\/+$/, "");
+  const c = child.startsWith("/") ? child : `/${child}`;
+  return (p + c).replace(/\/{2,}/g, "/") || "/";
+}
+async function expandRoutes(routes) {
+  const out = [];
+  const visit = async (records, parent) => {
+    for (const record of records) {
+      if (!record || typeof record.path !== "string") continue;
+      const full = parent ? joinPath(parent, record.path) : record.path;
+      if (record.children?.length) await visit(record.children, full);
+      if (full.includes("*")) continue;
+      if ("redirect" in record && record.redirect !== void 0) {
+        if (!/:/.test(full)) out.push(full);
+        continue;
+      }
+      if (/:/.test(full)) {
+        if (typeof record.getStaticPaths !== "function") continue;
+        let entries;
+        try {
+          entries = await record.getStaticPaths();
+        } catch (err) {
+          throw new Error(
+            `[sibu prerender] getStaticPaths() of "${full}" failed: ${err instanceof Error ? err.message : String(err)}. If it reads an API, start it and point \`prerender.fetch\` at it.`,
+            { cause: err }
+          );
+        }
+        for (const entry of entries) {
+          if (typeof entry === "string") {
+            out.push(entry);
+            continue;
+          }
+          let path = full;
+          for (const [key, value] of Object.entries(entry)) {
+            path = path.replace(new RegExp(`:${key}(?=[/?#]|$)`, "g"), encodeURIComponent(String(value)));
+          }
+          if (/:[A-Za-z_]/.test(path)) {
+            throw new Error(
+              `[sibu prerender] getStaticPaths() of "${full}" returned ${JSON.stringify(entry)}, which leaves a param unset`
+            );
+          }
+          out.push(path);
+        }
+        continue;
+      }
+      if (record.children?.length) continue;
+      out.push(full);
+    }
+  };
+  await visit(routes, "");
+  return Array.from(new Set(out));
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function decodeTitleText(text) {
+  const named = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\xA0" };
+  return text.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, (ref, body) => {
+    if (body[0] !== "#") return named[body.toLowerCase()] ?? ref;
+    const code = body[1] === "x" || body[1] === "X" ? Number.parseInt(body.slice(2), 16) : Number(body.slice(1));
+    return code > 0 && code <= 1114111 ? String.fromCodePoint(code) : ref;
+  });
+}
+function injectIntoShell(shell, parts, container = "app") {
+  let html = shell;
+  const shellTitle = /<title>([\s\S]*?)<\/title>/i.exec(html)?.[1] ?? "";
+  if (parts.head) {
+    let head = parts.head;
+    if (/<title>/i.test(head)) {
+      html = html.replace(/\s*<title>[\s\S]*?<\/title>/i, () => "");
+      const baseTitle = `<title data-sibu-base-title="${escapeAttr(decodeTitleText(shellTitle))}">`;
+      head = head.replace(/<title>/i, () => baseTitle);
+    }
+    const headHtml = head;
+    html = html.replace(/<\/head>/i, () => `    ${headHtml}
+  </head>`);
+  }
+  if (parts.body) {
+    const id = container.replace(/[^A-Za-z0-9_-]/g, "");
+    const open = new RegExp(`(<([a-z][a-z0-9-]*)\\b[^>]*\\bid\\s*=\\s*["']${id}["'][^>]*>)([\\s\\S]*?)(</\\2>)`, "i");
+    if (!open.test(html))
+      throw new Error(`[sibu prerender] the built index.html has no element with id="${id}" to render into`);
+    html = html.replace(
+      open,
+      (_m, openTag, _tag, _inner, close) => `${openTag}${parts.body}${close}`
+    );
+  }
+  if (parts.state) html = html.replace(/<\/body>/i, () => `  ${parts.state}
+  </body>`);
+  return html;
+}
+function assertPrerendered(url, result, failures, timeout) {
+  if (failures.length > 0) {
+    throw new Error(
+      `[sibu prerender] ${url}: ${failures[0]}. The page needs data from an API that is not reachable at build time \u2014 start it and point \`prerender.fetch\` at it, or skip the request with isPrerendering().`
+    );
+  }
+  const pending = result.diagnostics.pending.join(", ");
+  if (result.failure === "timeout") {
+    throw new Error(
+      `[sibu prerender] ${url}: the route did not render within ${timeout} ms (pending: ${pending}). A lazy import, a guard or a route load did not finish in time; fix it or raise \`prerender.timeout\`.`
+    );
+  }
+  if (result.diagnostics.timedOut) {
+    throw new Error(`[sibu prerender] ${url}: did not settle within ${timeout} ms (pending: ${pending})`);
+  }
+}
+function buildSitemap(origin, paths) {
+  const urls = paths.map((p) => `  <url><loc>${escapeXml(origin + p)}</loc></url>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>
+`;
+}
+async function prerenderFromServerEntry(options, ctx, helpers) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const { pathToFileURL } = await import("url");
+  const { AsyncLocalStorage } = await import("async_hooks");
+  const outDir = options.outDir ? path.resolve(ctx.root, options.outDir) : ctx.outDir;
+  const origin = (options.origin ?? "http://localhost").replace(/\/+$/, "");
+  const serverEntry = path.resolve(ctx.root, String(options.server).replace(/^\//, ""));
+  const keptShell = path.join(ctx.outDir, typeof options.shell === "string" ? options.shell : "200.html");
+  const shellPath = await fs.access(keptShell).then(() => keptShell).catch(() => path.join(ctx.outDir, "index.html"));
+  const shell = await fs.readFile(shellPath, "utf8");
+  const tmpDir = path.join(
+    outDir,
+    `.sibu-prerender-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`
+  );
+  await fs.rm(tmpDir, { recursive: true, force: true });
+  const viteBuild = await helpers.loadViteBuild();
+  const driverSource = `import { renderRoute } from "sibujs/ssr";
+import * as entry from ${JSON.stringify(serverEntry.split(path.sep).join("/"))};
+export { renderRoute, entry };
+`;
+  const prev = process.env[helpers.childEnv];
+  process.env[helpers.childEnv] = "1";
+  try {
+    await viteBuild({
+      configFile: ctx.configFile,
+      root: ctx.root,
+      mode: ctx.mode,
+      logLevel: "warn",
+      plugins: [
+        {
+          name: "sibu-prerender-driver",
+          resolveId: (id) => id === DRIVER_ID ? DRIVER_RESOLVED : null,
+          load: (id) => id === DRIVER_RESOLVED ? driverSource : null
+        }
+      ],
+      build: {
+        ssr: true,
+        outDir: tmpDir,
+        emptyOutDir: true,
+        copyPublicDir: false,
+        minify: false,
+        sourcemap: false,
+        rollupOptions: { input: DRIVER_ID, output: { format: "es", entryFileNames: "driver.mjs" } }
+      }
+    });
+  } finally {
+    if (prev === void 0) delete process.env[helpers.childEnv];
+    else process.env[helpers.childEnv] = prev;
+  }
+  await fs.writeFile(path.join(tmpDir, "package.json"), '{ "type": "module" }\n', "utf8");
+  const currentRoute = new AsyncLocalStorage();
+  const realFetch = globalThis.fetch;
+  const custom = typeof options.fetch === "function" ? options.fetch : null;
+  const apiBase = typeof options.fetch === "string" ? options.fetch.replace(/\/+$/, "") : origin;
+  const buildFetch = (async (input, init) => {
+    const raw = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const url = /^[a-z][a-z0-9+.-]*:/i.test(raw) ? raw : apiBase + (raw.startsWith("/") ? raw : `/${raw}`);
+    try {
+      return await (custom ?? realFetch)(
+        typeof input === "object" && !(input instanceof URL) ? new Request(url, input) : url,
+        init
+      );
+    } catch (err) {
+      const store = currentRoute.getStore();
+      const reason = err instanceof Error ? err.message : String(err);
+      store?.failures.push(`GET ${url} failed (${reason})`);
+      throw err;
+    }
+  });
+  const driverUrl = pathToFileURL(path.join(tmpDir, "driver.mjs")).href;
+  const results = [];
+  globalThis.fetch = buildFetch;
+  try {
+    const driver = await import(driverUrl);
+    const entry = driver.entry;
+    if (!Array.isArray(entry.routes)) {
+      throw new Error(
+        `[sibu prerender] the server entry ${options.server} must export \`routes\` (the app's route table)`
+      );
+    }
+    const explicit = Array.isArray(options.routes) ? options.routes : null;
+    const auto = explicit === null;
+    const listed = (explicit ? explicit.map((r) => typeof r === "string" ? { path: r } : r) : (await expandRoutes(entry.routes)).map((p) => ({ path: p }))).filter((r) => r.path !== options.notFound);
+    const trailingSlash = options.trailingSlash === "never" ? "never" : "always";
+    const planned = listed.map((route) => ({ route, file: helpers.outputFileFor(route, trailingSlash) }));
+    const seen = /* @__PURE__ */ new Map();
+    for (const { route, file } of planned) {
+      helpers.resolveInsideOutDir(path, outDir, file);
+      const other = seen.get(file);
+      if (other !== void 0) {
+        throw new Error(
+          `[sibu prerender] "${other}" and "${route.path}" would both be written to ${file}; a query variant needs its own \`output\` file.`
+        );
+      }
+      seen.set(file, route.path);
+    }
+    const renderOptions = {
+      router: { ...entry.routerOptions ?? {}, head: entry.head },
+      app: entry.app,
+      timeout: options.timeout ?? 15e3,
+      // A per-request page is written as the shell plus its route head: it is
+      // never rendered at build time, so its request-only fetches never run.
+      headOnly: ["ssr"],
+      hydration: options.hydration,
+      nonce: options.nonce,
+      maxStateBytes: options.maxStateBytes
+    };
+    const render = async (url) => {
+      const store = { route: url, failures: [] };
+      const result = await currentRoute.run(store, () => driver.renderRoute(entry.routes, url, renderOptions));
+      assertPrerendered(url, result, store.failures, renderOptions.timeout);
+      return result;
+    };
+    if (options.shell !== false) await fs.writeFile(path.join(outDir, options.shell ?? "200.html"), shell, "utf8");
+    const redirects = [];
+    const indexable = [];
+    const queue = [...planned];
+    const concurrency = Math.max(1, options.concurrency ?? 4);
+    const write = async (file, html) => {
+      const target = helpers.resolveInsideOutDir(path, outDir, file);
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      await fs.writeFile(target, html, "utf8");
+    };
+    await Promise.all(
+      Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+        for (let job = queue.shift(); job; job = queue.shift()) {
+          const { route, file } = job;
+          const started = Date.now();
+          const result = await render(route.path);
+          if (result.location !== null && result.redirectBy === "guard") {
+            results.push({
+              route: route.path,
+              file: "",
+              ms: Date.now() - started,
+              status: result.status,
+              kind: "skipped"
+            });
+            continue;
+          }
+          if (result.location !== null) {
+            redirects.push({ from: route.path, to: result.location, status: result.status });
+            results.push({
+              route: route.path,
+              file: "",
+              ms: Date.now() - started,
+              status: result.status,
+              kind: "redirect"
+            });
+            continue;
+          }
+          if (auto && result.failure === "guard") {
+            results.push({
+              route: route.path,
+              file: "",
+              ms: Date.now() - started,
+              status: result.status,
+              kind: "skipped"
+            });
+            continue;
+          }
+          if (result.status >= 400) {
+            throw new Error(
+              `[sibu prerender] ${route.path} answered ${result.status}${result.failure ? ` (${result.failure})` : ""}; list only pages that exist (the \`*\` route becomes 404.html through \`notFound\`).`
+            );
+          }
+          const body = result.render === "client" || result.render === "ssr" ? "" : result.html;
+          const state = body ? result.state : "";
+          await write(file, injectIntoShell(shell, { body, head: result.head, state }, options.container));
+          if (!result.noindex && result.render !== "client") {
+            const pathname = route.path.split(/[?#]/)[0];
+            indexable.push(
+              trailingSlash === "always" && pathname !== "/" ? `${pathname.replace(/\/+$/, "")}/` : pathname
+            );
+          }
+          results.push({
+            route: route.path,
+            file,
+            ms: Date.now() - started,
+            status: result.status,
+            kind: body ? "page" : "shell"
+          });
+        }
+      })
+    );
+    const notFound = options.notFound ?? "/404";
+    if (notFound) {
+      const started = Date.now();
+      const result = await render(notFound);
+      if (result.status === 404) {
+        await write(
+          "404.html",
+          injectIntoShell(shell, { body: result.html, head: result.head, state: result.state }, options.container)
+        );
+        results.push({ route: notFound, file: "404.html", ms: Date.now() - started, status: 404, kind: "not-found" });
+      }
+    }
+    if (redirects.length > 0) await write("redirects.json", `${JSON.stringify(redirects, null, 2)}
+`);
+    if (options.sitemap !== false && indexable.length > 0) {
+      indexable.sort();
+      await write("sitemap.xml", buildSitemap(origin, indexable));
+    }
+    if (options.robots) {
+      const extra = typeof options.robots === "string" ? `${options.robots.trim()}
+` : "";
+      const sitemapLine = options.sitemap !== false && indexable.length > 0 ? `Sitemap: ${origin}/sitemap.xml
+` : "";
+      await write("robots.txt", `User-agent: *
+Allow: /
+${extra}${sitemapLine}`);
+    }
+  } finally {
+    globalThis.fetch = realFetch;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+  return results;
+}
+export {
+  assertPrerendered,
+  buildSitemap,
+  expandRoutes,
+  injectIntoShell,
+  prerenderFromServerEntry
+};

package/dist/renderRoute-DP20XwMS.d.cts

@@ -0,0 +1,86 @@
+import { R as RouterOptions, a as RouteDef } from './routeHead-CE9SV-cH.cjs';
+import { A as AsyncRenderOptions, D as DocumentOptions, R as RenderResult } from './ssr-JpGpHnpC.cjs';
+
+/** How a route is treated by server renders (see `RouteBase.render`); `"default"` when no record declares one. */
+type RouteRenderMode = "ssr" | "prerender" | "client" | "default";
+/** Options of {@link renderRoute}. */
+interface RenderRouteOptions extends AsyncRenderOptions {
+    /**
+     * Milliseconds for the whole request (default 5000): the initial navigation,
+     * the matched components' loads, then building and settling the page. Past
+     * it before the route rendered, the result is a 503 with `failure:
+     * "timeout"`; past it while the page settles, what is ready is serialized
+     * with fallbacks (`diagnostics.timedOut`), as `renderToStringAsync` does.
+     */
+    timeout?: number;
+    /**
+     * Builds the page around the routed content. Default: `() => Route()`.
+     * Use your app shell (`() => App()`) when it contains the outlet.
+     */
+    app?: () => Node;
+    /** Router options (`head`, `base`, `guardTimeout`, …). `mode` and `url` are set by `renderRoute`. */
+    router?: Omit<RouterOptions, "mode" | "url">;
+    /** Status for a navigation a guard rejected. Default 403. Redirect from the guard for a login page (302). */
+    rejectStatus?: number;
+    /**
+     * Wrap the body in a full document (`renderToDocument`'s), with the
+     * collected head tags in `<head>` and the transfer script in `<body>`.
+     */
+    document?: DocumentOptions;
+    /**
+     * Render modes answered with the head alone, as `"client"` always is: the
+     * route is matched, guarded and redirected as usual, and its `head` is
+     * resolved from the route records, but no component (the route's or
+     * `app`'s) is built, so nothing it would fetch runs and nothing transfers.
+     * The pre-renderer passes `["ssr"]`: a per-request page ships as the shell
+     * plus its route head, without rendering it at build time.
+     * @internal
+     */
+    headOnly?: readonly RouteRenderMode[];
+}
+/** The routed part of a {@link renderRoute} result. */
+interface RenderedRoute {
+    /** The committed path (after redirects). */
+    path: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    hash: string;
+    /** `name` of the deepest matched record, if it has one. */
+    name: string | null;
+}
+/** Result of {@link renderRoute}. */
+interface RouteRenderResult extends RenderResult {
+    /** `Location` header value for a redirect, else `null`. */
+    location: string | null;
+    /** The committed route, or `null` when the navigation was rejected or failed. */
+    route: RenderedRoute | null;
+    /** The route's rendering mode; for `"client"` the body is empty (shell plus head). */
+    render: RouteRenderMode;
+    /** True when the route's head declares `robots: noindex` (left out of a sitemap). */
+    noindex: boolean;
+    /** Why the navigation did not commit (`"guard"`, `"redirect-loop"`, …), else `null`. */
+    failure: string | null;
+    /**
+     * Who answered with the redirect: a `redirect` record (`"route"`, the same
+     * for every visitor) or a guard (`"guard"`, it depends on the visitor).
+     */
+    redirectBy: "route" | "guard" | null;
+}
+/**
+ * Render one URL through the router, in its own request scope.
+ *
+ * @param routes The app's route table (the same one the browser uses).
+ * @param url The request URL path with query and hash (`"/cotizar?servicio=dtf"`).
+ * @param options App shell, router options, settle timeout, state transfer, document.
+ * @returns HTML, head, transfer state, HTTP status, redirect location, route, diagnostics.
+ *
+ * @example
+ * ```ts
+ * const r = await renderRoute(routes, req.url, { router: { head }, document: { scripts: ["/assets/main.js"] } });
+ * if (r.location) return res.redirect(r.status, r.location);
+ * res.status(r.status).send(r.html);
+ * ```
+ */
+declare function renderRoute(routes: RouteDef[], url: string, options?: RenderRouteOptions): Promise<RouteRenderResult>;
+
+export { type RenderRouteOptions as R, type RouteRenderResult as a, type RenderedRoute as b, type RouteRenderMode as c, renderRoute as r };

package/dist/renderRoute-fxgsm2Ir.d.ts

@@ -0,0 +1,86 @@
+import { R as RouterOptions, a as RouteDef } from './routeHead-DzVxPviY.js';
+import { A as AsyncRenderOptions, D as DocumentOptions, R as RenderResult } from './ssr-JpGpHnpC.js';
+
+/** How a route is treated by server renders (see `RouteBase.render`); `"default"` when no record declares one. */
+type RouteRenderMode = "ssr" | "prerender" | "client" | "default";
+/** Options of {@link renderRoute}. */
+interface RenderRouteOptions extends AsyncRenderOptions {
+    /**
+     * Milliseconds for the whole request (default 5000): the initial navigation,
+     * the matched components' loads, then building and settling the page. Past
+     * it before the route rendered, the result is a 503 with `failure:
+     * "timeout"`; past it while the page settles, what is ready is serialized
+     * with fallbacks (`diagnostics.timedOut`), as `renderToStringAsync` does.
+     */
+    timeout?: number;
+    /**
+     * Builds the page around the routed content. Default: `() => Route()`.
+     * Use your app shell (`() => App()`) when it contains the outlet.
+     */
+    app?: () => Node;
+    /** Router options (`head`, `base`, `guardTimeout`, …). `mode` and `url` are set by `renderRoute`. */
+    router?: Omit<RouterOptions, "mode" | "url">;
+    /** Status for a navigation a guard rejected. Default 403. Redirect from the guard for a login page (302). */
+    rejectStatus?: number;
+    /**
+     * Wrap the body in a full document (`renderToDocument`'s), with the
+     * collected head tags in `<head>` and the transfer script in `<body>`.
+     */
+    document?: DocumentOptions;
+    /**
+     * Render modes answered with the head alone, as `"client"` always is: the
+     * route is matched, guarded and redirected as usual, and its `head` is
+     * resolved from the route records, but no component (the route's or
+     * `app`'s) is built, so nothing it would fetch runs and nothing transfers.
+     * The pre-renderer passes `["ssr"]`: a per-request page ships as the shell
+     * plus its route head, without rendering it at build time.
+     * @internal
+     */
+    headOnly?: readonly RouteRenderMode[];
+}
+/** The routed part of a {@link renderRoute} result. */
+interface RenderedRoute {
+    /** The committed path (after redirects). */
+    path: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    hash: string;
+    /** `name` of the deepest matched record, if it has one. */
+    name: string | null;
+}
+/** Result of {@link renderRoute}. */
+interface RouteRenderResult extends RenderResult {
+    /** `Location` header value for a redirect, else `null`. */
+    location: string | null;
+    /** The committed route, or `null` when the navigation was rejected or failed. */
+    route: RenderedRoute | null;
+    /** The route's rendering mode; for `"client"` the body is empty (shell plus head). */
+    render: RouteRenderMode;
+    /** True when the route's head declares `robots: noindex` (left out of a sitemap). */
+    noindex: boolean;
+    /** Why the navigation did not commit (`"guard"`, `"redirect-loop"`, …), else `null`. */
+    failure: string | null;
+    /**
+     * Who answered with the redirect: a `redirect` record (`"route"`, the same
+     * for every visitor) or a guard (`"guard"`, it depends on the visitor).
+     */
+    redirectBy: "route" | "guard" | null;
+}
+/**
+ * Render one URL through the router, in its own request scope.
+ *
+ * @param routes The app's route table (the same one the browser uses).
+ * @param url The request URL path with query and hash (`"/cotizar?servicio=dtf"`).
+ * @param options App shell, router options, settle timeout, state transfer, document.
+ * @returns HTML, head, transfer state, HTTP status, redirect location, route, diagnostics.
+ *
+ * @example
+ * ```ts
+ * const r = await renderRoute(routes, req.url, { router: { head }, document: { scripts: ["/assets/main.js"] } });
+ * if (r.location) return res.redirect(r.status, r.location);
+ * res.status(r.status).send(r.html);
+ * ```
+ */
+declare function renderRoute(routes: RouteDef[], url: string, options?: RenderRouteOptions): Promise<RouteRenderResult>;
+
+export { type RenderRouteOptions as R, type RouteRenderResult as a, type RenderedRoute as b, type RouteRenderMode as c, renderRoute as r };