@fluixi/start 0.1.0-alpha.73 → 0.1.0-alpha.75

package/dist/commands/prerender.cjs

@@ -0,0 +1,404 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/prerender.ts
+var prerender_exports = {};
+__export(prerender_exports, {
+  extractLinks: () => extractLinks,
+  htmlPath: () => htmlPath,
+  prerender: () => prerender
+});
+module.exports = __toCommonJS(prerender_exports);
+var import_promises2 = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+
+// src/config.ts
+var import_node_path = require("node:path");
+function resolveConfig(config = {}) {
+  const root = (0, import_node_path.resolve)(config.root ?? process.cwd());
+  return {
+    root,
+    ssr: config.ssr ?? true,
+    port: config.port ?? 3e3,
+    serverEntry: config.serverEntry ?? "src/entry-server.ts",
+    clientEntry: config.clientEntry ?? "src/entry-client.ts",
+    template: config.template ?? "index.html",
+    mountId: config.mountId ?? "root",
+    routesDir: config.routesDir ?? "src/routes",
+    apiDir: config.apiDir ?? "src/api",
+    middleware: config.middleware ?? "src/middleware.ts",
+    ssrNoExternal: config.ssrNoExternal ?? [],
+    resolve: config.resolve ?? [],
+    vitePlugin: config.vitePlugin ?? {},
+    plugins: config.plugins ?? [],
+    adapter: config.adapter,
+    i18n: resolveI18n(config.i18n),
+    prerender: resolvePrerender(config.prerender)
+  };
+}
+function resolvePrerender(prerender2) {
+  if (!prerender2) return false;
+  const opts = typeof prerender2 === "object" ? prerender2 : {};
+  return {
+    routes: opts.routes?.length ? opts.routes : ["/"],
+    crawl: opts.crawl ?? true
+  };
+}
+function resolveI18n(i18n) {
+  if (i18n === false) return false;
+  const opts = typeof i18n === "object" ? i18n : {};
+  return {
+    dir: opts.dir ?? "src/i18n",
+    defaultLocale: opts.defaultLocale,
+    locales: opts.locales
+  };
+}
+
+// src/adapter.ts
+var import_promises = require("node:fs/promises");
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+var import_node_url = require("node:url");
+
+// src/handler.ts
+function streamDocument(head, body, tail) {
+  const enc = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        controller.enqueue(enc.encode(head));
+        const reader = body.getReader();
+        for (; ; ) {
+          const { done: done2, value } = await reader.read();
+          if (done2) break;
+          controller.enqueue(value);
+        }
+        controller.enqueue(enc.encode(tail));
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: { "content-type": "text/html; charset=utf-8" }
+  });
+}
+function createRequestHandler(render) {
+  return async (request) => {
+    const url = new URL(request.url);
+    try {
+      const html = await render(url.pathname + url.search, request);
+      return new Response(html, {
+        status: 200,
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    } catch (e) {
+      return new Response(String(e?.stack || e), {
+        status: 500,
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+
+// src/document.ts
+var import_head = require("@fluixi/head");
+function injectApp(template, appHtml, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  if (mount.test(template)) {
+    return template.replace(mount, `<div id="${mountId}">${appHtml}</div>`);
+  }
+  if (template.includes("<!--ssr-outlet-->")) {
+    return template.replace("<!--ssr-outlet-->", appHtml);
+  }
+  return template.replace("</body>", `<div id="${mountId}">${appHtml}</div></body>`);
+}
+function splitTemplate(template, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  const m = template.match(mount);
+  if (m && m.index !== void 0) {
+    return {
+      head: template.slice(0, m.index) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(m.index + m[0].length)
+    };
+  }
+  const outlet = template.indexOf("<!--ssr-outlet-->");
+  if (outlet !== -1) {
+    return {
+      head: template.slice(0, outlet),
+      tail: template.slice(outlet + "<!--ssr-outlet-->".length)
+    };
+  }
+  const body = template.indexOf("</body>");
+  if (body !== -1) {
+    return {
+      head: template.slice(0, body) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(body)
+    };
+  }
+  return { head: template, tail: "" };
+}
+function injectPreload(template, files) {
+  const tags = files.filter((file) => !template.includes(file)).map(
+    (file) => file.endsWith(".css") ? `<link rel="stylesheet" href="${file}">` : (
+      // `modulepreload` also fetches the chunk's own static imports.
+      `<link rel="modulepreload" href="${file}">`
+    )
+  );
+  if (tags.length === 0) return template;
+  const head = template.indexOf("</head>");
+  if (head === -1) return template;
+  return template.slice(0, head) + tags.join("") + template.slice(head);
+}
+function setHtmlAttr(html, name, value) {
+  const existing = new RegExp(`(<html\\b[^>]*?)\\s${name}="[^"]*"`, "i");
+  if (existing.test(html)) return html.replace(existing, `$1 ${name}="${value}"`);
+  return html.replace(/<html\b/i, `<html ${name}="${value}"`);
+}
+function injectAppAndHead(template, rendered, mountId = "root") {
+  const { head, body } = (0, import_head.extractHeadMarker)(rendered);
+  let html = injectApp(template, body, mountId);
+  if (head) {
+    if (head.headHtml) {
+      if (/<title[\s>]/i.test(head.headHtml)) html = html.replace(/<title>[\s\S]*?<\/title>/i, "");
+      html = html.replace("</head>", `${head.headHtml}</head>`);
+    }
+    for (const [k, v] of Object.entries(head.htmlAttrs)) html = setHtmlAttr(html, k, v);
+  }
+  return html;
+}
+function guardHandler(handler, onError) {
+  return async (request) => {
+    try {
+      return await handler(request);
+    } catch (e) {
+      onError?.(e);
+      return new Response(String(e?.stack || e), {
+        status: 500,
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+
+// src/middleware.ts
+function normalizeMiddleware(mod) {
+  const def = mod?.default ?? mod;
+  if (def == null) return [];
+  if (Array.isArray(def)) return def.filter((m) => typeof m === "function");
+  return typeof def === "function" ? [def] : [];
+}
+function composeMiddleware(middlewares, core) {
+  if (middlewares.length === 0) return core;
+  return (request) => {
+    let lastCalled = -1;
+    const dispatch = (i) => {
+      if (i <= lastCalled) {
+        return Promise.reject(new Error("middleware called next() more than once"));
+      }
+      lastCalled = i;
+      const mw = middlewares[i];
+      if (!mw) return Promise.resolve(core(request));
+      return Promise.resolve(mw(request, () => dispatch(i + 1)));
+    };
+    return dispatch(0);
+  };
+}
+
+// src/handler-core.ts
+function createHandlerFrom({ template, mod, cfg, middleware, preload }) {
+  const withPreload = (html, pathname) => preload ? injectPreload(html, preload(pathname)) : html;
+  let core;
+  if (!cfg.ssr) {
+    core = createRequestHandler(async (url) => withPreload(template, url.split("?")[0]));
+  } else if (typeof mod.renderStream === "function") {
+    core = async (request) => {
+      const url = new URL(request.url);
+      const { head, tail } = splitTemplate(withPreload(template, url.pathname), cfg.mountId);
+      const body = await mod.renderStream(url.pathname + url.search, request);
+      return streamDocument(head, body, tail);
+    };
+  } else {
+    const render = mod.render ?? mod.default;
+    core = createRequestHandler(
+      async (url, request) => (
+        // `url` here is `pathname + search`; matching only ever wants the path.
+        injectAppAndHead(withPreload(template, url.split("?")[0]), await render(url, request), cfg.mountId)
+      )
+    );
+  }
+  if (typeof mod.handleServerFn === "function" && typeof mod.isServerFnRequest === "function") {
+    const render = core;
+    core = async (request) => mod.isServerFnRequest(request) ? mod.handleServerFn(request) : render(request);
+  }
+  if (typeof mod.handleApiRequest === "function" && typeof mod.isApiRequest === "function") {
+    const next = core;
+    core = async (request) => mod.isApiRequest(request) ? mod.handleApiRequest(request) : next(request);
+  }
+  if (!middleware) return guardHandler(core);
+  return guardHandler(composeMiddleware(normalizeMiddleware(middleware), core));
+}
+
+// src/preload.ts
+var import_router = require("@fluixi/core/router");
+function createPreloader(assets) {
+  const patterns = Object.keys(assets ?? {});
+  if (!patterns.length) return () => [];
+  const routes = patterns.map((path) => ({ path, meta: { path } }));
+  return (pathname) => {
+    const matched = (0, import_router.matchRoutes)(routes, pathname)?.matched;
+    const leaf = matched?.[matched.length - 1];
+    const pattern = leaf?.route.meta?.path;
+    return pattern ? assets[pattern] ?? [] : [];
+  };
+}
+
+// src/adapter.ts
+async function createProdHandler(config = {}) {
+  const cfg = resolveConfig(config);
+  const clientDir = (0, import_node_path2.resolve)(cfg.root, "dist/client");
+  const template = await readTemplate(clientDir, (0, import_node_path2.resolve)(cfg.root, "dist/server"));
+  const serverEntry = (0, import_node_path2.resolve)(cfg.root, "dist/server", "entry-server.js");
+  const mod = (0, import_node_fs.existsSync)(serverEntry) ? await import(
+    /* @vite-ignore */
+    (0, import_node_url.pathToFileURL)(serverEntry).href
+  ) : {};
+  const mwFile = (0, import_node_path2.resolve)(cfg.root, "dist/server", "middleware.js");
+  const middleware = (0, import_node_fs.existsSync)(mwFile) ? await import(
+    /* @vite-ignore */
+    (0, import_node_url.pathToFileURL)(mwFile).href
+  ) : void 0;
+  return createHandlerFrom({ template, mod, cfg, middleware, preload: await loadPreloader(cfg) });
+}
+async function readTemplate(clientDir, serverDir) {
+  const stashed = (0, import_node_path2.join)(serverDir, "template.html");
+  return (0, import_promises.readFile)((0, import_node_fs.existsSync)(stashed) ? stashed : (0, import_node_path2.join)(clientDir, "index.html"), "utf-8");
+}
+async function loadPreloader(cfg) {
+  const file = (0, import_node_path2.resolve)(cfg.root, "dist/server", "route-assets.json");
+  if (!(0, import_node_fs.existsSync)(file)) return void 0;
+  try {
+    return createPreloader(JSON.parse(await (0, import_promises.readFile)(file, "utf-8")));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/ui.ts
+var COLOR = process.env.NO_COLOR || process.env.FORCE_COLOR === "0" ? false : (!!process.stdout.isTTY || !!process.env.FORCE_COLOR) && process.env.TERM !== "dumb";
+var sgr = (open, close) => (s) => COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : `${s}`;
+var c = {
+  bold: sgr(1, 22),
+  dim: sgr(2, 22),
+  italic: sgr(3, 23),
+  underline: sgr(4, 24),
+  red: sgr(31, 39),
+  green: sgr(32, 39),
+  yellow: sgr(33, 39),
+  blue: sgr(34, 39),
+  magenta: sgr(35, 39),
+  cyan: sgr(36, 39),
+  gray: sgr(90, 39)
+};
+var SYM = {
+  arrow: c.gray("➜"),
+  ok: c.green("✓"),
+  err: c.red("✗")
+};
+function step(text) {
+  process.stdout.write(`  ${c.cyan("•")} ${text}
+`);
+}
+function done(text) {
+  process.stdout.write(`  ${SYM.ok} ${text}
+`);
+}
+
+// src/commands/prerender.ts
+function htmlPath(url) {
+  const clean = url.split(/[?#]/)[0].replace(/\/+$/, "");
+  return clean === "" ? "index.html" : `${clean.replace(/^\//, "")}/index.html`;
+}
+function extractLinks(html) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of html.matchAll(/href=["'](\/[^"'#?]*)["']/g)) {
+    const href = m[1];
+    if (/\.[a-z0-9]+$/i.test(href)) continue;
+    out.add(href.replace(/\/+$/, "") || "/");
+  }
+  return [...out];
+}
+var norm = (u) => {
+  const p = (u.startsWith("/") ? u : "/" + u).replace(/\/+$/, "");
+  return p || "/";
+};
+async function prerender(config = {}) {
+  const cfg = resolveConfig(config);
+  if (!cfg.prerender) return [];
+  if (!cfg.ssr) {
+    process.stdout.write(`  ${c.yellow("!")} prerender needs ssr:true — skipped
+`);
+    return [];
+  }
+  step("prerender");
+  const clientDir = (0, import_node_path3.resolve)(cfg.root, "dist/client");
+  const handler = await createProdHandler(config);
+  const { routes, crawl } = cfg.prerender;
+  const queue = routes.map(norm);
+  const seen = /* @__PURE__ */ new Set();
+  const written = [];
+  while (queue.length) {
+    const url = queue.shift();
+    if (seen.has(url)) continue;
+    seen.add(url);
+    let html;
+    try {
+      const res = await handler(new Request("http://prerender.local" + url));
+      if (!res.ok) {
+        process.stdout.write(`    ${c.yellow("skip")} ${url} ${c.gray("→ " + res.status)}
+`);
+        continue;
+      }
+      if (!(res.headers.get("content-type") || "").includes("html")) continue;
+      html = await res.text();
+    } catch (e) {
+      process.stdout.write(`    ${c.yellow("skip")} ${url} ${c.gray("→ " + e.message)}
+`);
+      continue;
+    }
+    const file = (0, import_node_path3.join)(clientDir, htmlPath(url));
+    await (0, import_promises2.mkdir)((0, import_node_path3.dirname)(file), { recursive: true });
+    await (0, import_promises2.writeFile)(file, html);
+    written.push(url);
+    if (crawl) {
+      for (const link of extractLinks(html)) if (!seen.has(link)) queue.push(link);
+    }
+  }
+  done(`${c.bold("prerendered")} ${c.bold(String(written.length))} page(s)  ${c.gray("→ dist/client")}
+`);
+  return written;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractLinks,
+  htmlPath,
+  prerender
+});

package/dist/commands/prerender.d.ts

@@ -2,7 +2,7 @@ import type { FluixiConfig } from '../config.js';
 export declare function htmlPath(url: string): string;
 export declare function extractLinks(html: string): string[];
 /**
- * Render routes to static HTML in dist/client, via the real prod handler — so each page is
+ * Render routes to static HTML in dist/client, via the real prod handler, so each page is
  * byte-identical to what `fluixi start` would serve (assets, __FX_DATA__, hydration), it just
  * lives on disk. Seeds from `prerender.routes` (default `/`) and, when `crawl`, follows internal
  * links. Returns the written route paths.

package/dist/commands/prerender.js

@@ -8,7 +8,7 @@ export function htmlPath(url) {
     const clean = url.split(/[?#]/)[0].replace(/\/+$/, '');
     return clean === '' ? 'index.html' : `${clean.replace(/^\//, '')}/index.html`;
 }
-// internal links from rendered HTML — skip files (.js/.css/…), anchors, queries, external
+// internal links from rendered HTML: skip files (.js/.css/…), anchors, queries, external
 export function extractLinks(html) {
     const out = new Set();
     for (const m of html.matchAll(/href=["'](\/[^"'#?]*)["']/g)) {
@@ -24,7 +24,7 @@ const norm = (u) => {
     return p || '/';
 };
 /**
- * Render routes to static HTML in dist/client, via the real prod handler — so each page is
+ * Render routes to static HTML in dist/client, via the real prod handler, so each page is
  * byte-identical to what `fluixi start` would serve (assets, __FX_DATA__, hydration), it just
  * lives on disk. Seeds from `prerender.routes` (default `/`) and, when `crawl`, follows internal
  * links. Returns the written route paths.