@fluixi/start 0.1.0-alpha.72 → 0.1.0-alpha.74

package/dist/adapters/entry.cjs

@@ -0,0 +1,122 @@
+"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/adapters/entry.ts
+var entry_exports = {};
+__export(entry_exports, {
+  cloudflareEntry: () => cloudflareEntry,
+  netlifyEntry: () => netlifyEntry,
+  vercelEntry: () => vercelEntry
+});
+module.exports = __toCommonJS(entry_exports);
+function preamble({ serverEntry, middleware, template, ssr, mountId, routeAssets }) {
+  return [
+    `import { createHandlerFrom } from '@fluixi/start/handler-core';`,
+    `import { createPreloader } from '@fluixi/start/preload';`,
+    `import * as server from ${JSON.stringify(serverEntry)};`,
+    middleware ? `import * as middleware from ${JSON.stringify(middleware)};` : "",
+    ``,
+    `const template = ${JSON.stringify(template)};`,
+    // Inlined for the same reason as the template: this runs as an uploaded file, with
+    // no dist/server beside it to read.
+    `const routeAssets = ${JSON.stringify(routeAssets)};`,
+    `const handler = createHandlerFrom({`,
+    `  template,`,
+    `  mod: server,`,
+    `  cfg: { ssr: ${ssr}, mountId: ${JSON.stringify(mountId)} },`,
+    `  preload: createPreloader(routeAssets),`,
+    middleware ? `  middleware,` : "",
+    `});`
+  ].filter(Boolean).join("\n");
+}
+function cloudflareEntry(source) {
+  return `${preamble(source)}
+
+const prerendered = new Set(${JSON.stringify(source.prerendered)});
+
+export default {
+  async fetch(request, env, ctx) {
+    // Static first, but only for what is static. ASSETS answers "/" with index.html
+    // whether that is a prerendered page or the shell, so asking about every path
+    // costs an SSR app its home page. Extension means a file, prerendered means a
+    // page, the rest is the handler's — the rule \`withStaticFiles\` already uses.
+    const { pathname } = new URL(request.url);
+    if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
+      const asset = await env.ASSETS.fetch(request.clone());
+      if (asset.status !== 404) return asset;
+    }
+    return handler(request, { env, ctx });
+  },
+};
+`;
+}
+function netlifyEntry(source) {
+  return `${preamble(source)}
+
+export default async (request, context) => handler(request, { context });
+
+export const config = { path: '/*', preferStatic: true };
+`;
+}
+function vercelEntry(source) {
+  return `${preamble(source)}
+
+export default async (req, res) => {
+  const proto = req.headers['x-forwarded-proto'] || 'https';
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const one of value) headers.append(name, one);
+    else if (value !== undefined) headers.set(name, value);
+  }
+
+  // A body has to be read off the stream before it can be handed to Request; only
+  // GET and HEAD are guaranteed not to have one.
+  let body;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length) body = new Blob(chunks);
+  }
+
+  const response = await handler(
+    new Request(new URL(req.url, \`\${proto}://\${host}\`), { method: req.method, headers, body }),
+  );
+
+  res.statusCode = response.status;
+  // set-cookie is the one header that legitimately repeats; folding it into one line
+  // breaks the cookies.
+  for (const [name, value] of response.headers) {
+    if (name.toLowerCase() !== 'set-cookie') res.setHeader(name, value);
+  }
+  const cookies = response.headers.getSetCookie?.() ?? [];
+  if (cookies.length) res.setHeader('set-cookie', cookies);
+
+  if (response.body) for await (const chunk of response.body) res.write(chunk);
+  res.end();
+};
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloudflareEntry,
+  netlifyEntry,
+  vercelEntry
+});

package/dist/adapters/entry.mjs

@@ -0,0 +1,95 @@
+// src/adapters/entry.ts
+function preamble({ serverEntry, middleware, template, ssr, mountId, routeAssets }) {
+  return [
+    `import { createHandlerFrom } from '@fluixi/start/handler-core';`,
+    `import { createPreloader } from '@fluixi/start/preload';`,
+    `import * as server from ${JSON.stringify(serverEntry)};`,
+    middleware ? `import * as middleware from ${JSON.stringify(middleware)};` : "",
+    ``,
+    `const template = ${JSON.stringify(template)};`,
+    // Inlined for the same reason as the template: this runs as an uploaded file, with
+    // no dist/server beside it to read.
+    `const routeAssets = ${JSON.stringify(routeAssets)};`,
+    `const handler = createHandlerFrom({`,
+    `  template,`,
+    `  mod: server,`,
+    `  cfg: { ssr: ${ssr}, mountId: ${JSON.stringify(mountId)} },`,
+    `  preload: createPreloader(routeAssets),`,
+    middleware ? `  middleware,` : "",
+    `});`
+  ].filter(Boolean).join("\n");
+}
+function cloudflareEntry(source) {
+  return `${preamble(source)}
+
+const prerendered = new Set(${JSON.stringify(source.prerendered)});
+
+export default {
+  async fetch(request, env, ctx) {
+    // Static first, but only for what is static. ASSETS answers "/" with index.html
+    // whether that is a prerendered page or the shell, so asking about every path
+    // costs an SSR app its home page. Extension means a file, prerendered means a
+    // page, the rest is the handler's — the rule \`withStaticFiles\` already uses.
+    const { pathname } = new URL(request.url);
+    if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
+      const asset = await env.ASSETS.fetch(request.clone());
+      if (asset.status !== 404) return asset;
+    }
+    return handler(request, { env, ctx });
+  },
+};
+`;
+}
+function netlifyEntry(source) {
+  return `${preamble(source)}
+
+export default async (request, context) => handler(request, { context });
+
+export const config = { path: '/*', preferStatic: true };
+`;
+}
+function vercelEntry(source) {
+  return `${preamble(source)}
+
+export default async (req, res) => {
+  const proto = req.headers['x-forwarded-proto'] || 'https';
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const one of value) headers.append(name, one);
+    else if (value !== undefined) headers.set(name, value);
+  }
+
+  // A body has to be read off the stream before it can be handed to Request; only
+  // GET and HEAD are guaranteed not to have one.
+  let body;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length) body = new Blob(chunks);
+  }
+
+  const response = await handler(
+    new Request(new URL(req.url, \`\${proto}://\${host}\`), { method: req.method, headers, body }),
+  );
+
+  res.statusCode = response.status;
+  // set-cookie is the one header that legitimately repeats; folding it into one line
+  // breaks the cookies.
+  for (const [name, value] of response.headers) {
+    if (name.toLowerCase() !== 'set-cookie') res.setHeader(name, value);
+  }
+  const cookies = response.headers.getSetCookie?.() ?? [];
+  if (cookies.length) res.setHeader('set-cookie', cookies);
+
+  if (response.body) for await (const chunk of response.body) res.write(chunk);
+  res.end();
+};
+`;
+}
+export {
+  cloudflareEntry,
+  netlifyEntry,
+  vercelEntry
+};

package/dist/adapters/platforms.cjs

@@ -0,0 +1,311 @@
+"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/adapters/platforms.ts
+var platforms_exports = {};
+__export(platforms_exports, {
+  cloudflareAdapter: () => cloudflareAdapter,
+  netlifyAdapter: () => netlifyAdapter,
+  vercelAdapter: () => vercelAdapter
+});
+module.exports = __toCommonJS(platforms_exports);
+var import_promises2 = require("node:fs/promises");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/adapter.ts
+var import_promises = require("node:fs/promises");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// src/document.ts
+var import_head = require("@fluixi/head");
+
+// src/preload.ts
+var import_router = require("@fluixi/core/router");
+
+// src/adapter.ts
+async function readTemplate(clientDir, serverDir) {
+  const stashed = (0, import_node_path.join)(serverDir, "template.html");
+  return (0, import_promises.readFile)((0, import_node_fs.existsSync)(stashed) ? stashed : (0, import_node_path.join)(clientDir, "index.html"), "utf-8");
+}
+
+// src/adapters/entry.ts
+function preamble({ serverEntry, middleware, template, ssr, mountId, routeAssets }) {
+  return [
+    `import { createHandlerFrom } from '@fluixi/start/handler-core';`,
+    `import { createPreloader } from '@fluixi/start/preload';`,
+    `import * as server from ${JSON.stringify(serverEntry)};`,
+    middleware ? `import * as middleware from ${JSON.stringify(middleware)};` : "",
+    ``,
+    `const template = ${JSON.stringify(template)};`,
+    // Inlined for the same reason as the template: this runs as an uploaded file, with
+    // no dist/server beside it to read.
+    `const routeAssets = ${JSON.stringify(routeAssets)};`,
+    `const handler = createHandlerFrom({`,
+    `  template,`,
+    `  mod: server,`,
+    `  cfg: { ssr: ${ssr}, mountId: ${JSON.stringify(mountId)} },`,
+    `  preload: createPreloader(routeAssets),`,
+    middleware ? `  middleware,` : "",
+    `});`
+  ].filter(Boolean).join("\n");
+}
+function cloudflareEntry(source) {
+  return `${preamble(source)}
+
+const prerendered = new Set(${JSON.stringify(source.prerendered)});
+
+export default {
+  async fetch(request, env, ctx) {
+    // Static first, but only for what is static. ASSETS answers "/" with index.html
+    // whether that is a prerendered page or the shell, so asking about every path
+    // costs an SSR app its home page. Extension means a file, prerendered means a
+    // page, the rest is the handler's — the rule \`withStaticFiles\` already uses.
+    const { pathname } = new URL(request.url);
+    if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
+      const asset = await env.ASSETS.fetch(request.clone());
+      if (asset.status !== 404) return asset;
+    }
+    return handler(request, { env, ctx });
+  },
+};
+`;
+}
+function netlifyEntry(source) {
+  return `${preamble(source)}
+
+export default async (request, context) => handler(request, { context });
+
+export const config = { path: '/*', preferStatic: true };
+`;
+}
+function vercelEntry(source) {
+  return `${preamble(source)}
+
+export default async (req, res) => {
+  const proto = req.headers['x-forwarded-proto'] || 'https';
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const one of value) headers.append(name, one);
+    else if (value !== undefined) headers.set(name, value);
+  }
+
+  // A body has to be read off the stream before it can be handed to Request; only
+  // GET and HEAD are guaranteed not to have one.
+  let body;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length) body = new Blob(chunks);
+  }
+
+  const response = await handler(
+    new Request(new URL(req.url, \`\${proto}://\${host}\`), { method: req.method, headers, body }),
+  );
+
+  res.statusCode = response.status;
+  // set-cookie is the one header that legitimately repeats; folding it into one line
+  // breaks the cookies.
+  for (const [name, value] of response.headers) {
+    if (name.toLowerCase() !== 'set-cookie') res.setHeader(name, value);
+  }
+  const cookies = response.headers.getSetCookie?.() ?? [];
+  if (cookies.length) res.setHeader('set-cookie', cookies);
+
+  if (response.body) for await (const chunk of response.body) res.write(chunk);
+  res.end();
+};
+`;
+}
+
+// src/adapters/platforms.ts
+async function entrySource(ctx, from, prerendered) {
+  const template = await readTemplate(ctx.clientDir, ctx.serverDir);
+  const assetFile = (0, import_node_path2.join)(ctx.serverDir, "route-assets.json");
+  const routeAssets = (0, import_node_fs2.existsSync)(assetFile) ? JSON.parse(await (0, import_promises2.readFile)(assetFile, "utf-8")) : {};
+  const middleware = (0, import_node_path2.join)(ctx.serverDir, "middleware.js");
+  const rel = (file) => {
+    const path = (0, import_node_path2.join)(ctx.serverDir, file).replace(/\\/g, "/");
+    return path.startsWith("/") ? path : `./${path}`;
+  };
+  return {
+    serverEntry: rel("entry-server.js"),
+    middleware: (0, import_node_fs2.existsSync)(middleware) ? rel("middleware.js") : null,
+    template,
+    ssr: ctx.cfg.ssr,
+    mountId: ctx.cfg.mountId,
+    prerendered,
+    routeAssets
+  };
+}
+function indexIsPage(template, mountId) {
+  const mount = new RegExp(`<([a-z-]+)[^>]*\\sid=["']${mountId}["'][^>]*>`, "i").exec(template);
+  if (!mount) return false;
+  return !template.slice(mount.index + mount[0].length).trimStart().startsWith("</");
+}
+function skipWhenStatic(ctx, name) {
+  if (ctx.hasServer) return false;
+  console.log(`  fluixi: no server entry — ${name} gets the static output alone.`);
+  return true;
+}
+async function appendRedirect(clientDir, rule) {
+  const file = (0, import_node_path2.join)(clientDir, "_redirects");
+  const existing = await (0, import_promises2.readFile)(file, "utf-8").catch(() => "");
+  if (existing.includes(rule)) return;
+  const separator = existing && !existing.endsWith("\n") ? "\n" : "";
+  await (0, import_promises2.writeFile)(file, `${existing}${separator}${rule}
+`);
+}
+var SPA_FALLBACK = "/*  /index.html  200";
+var CF_MAX_RULES = 100;
+async function prerenderedRoutes(dir, mountId) {
+  const out = [];
+  const walk = async (current) => {
+    for (const entry of await (0, import_promises2.readdir)(current, { withFileTypes: true })) {
+      const path = (0, import_node_path2.join)(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "assets" || entry.name.startsWith(".")) continue;
+        await walk(path);
+      } else if (entry.name.endsWith(".html")) {
+        const rel = (0, import_node_path2.relative)(dir, path).replace(/\\/g, "/").replace(/index\.html$/, "").replace(/\.html$/, "");
+        out.push("/" + rel.replace(/\/$/, ""));
+      }
+    }
+  };
+  await walk(dir);
+  const index = await (0, import_promises2.readFile)((0, import_node_path2.join)(dir, "index.html"), "utf-8").catch(() => "");
+  const root = indexIsPage(index, mountId);
+  return out.filter((r) => r !== "/" || root).sort();
+}
+var cloudflareAdapter = {
+  name: "cloudflare",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    if (skipWhenStatic(ctx, "cloudflare")) return;
+    const out = (0, import_node_path2.join)(ctx.clientDir, "_worker.js");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(cloudflareEntry(await entrySource(ctx, out, prerendered)), out);
+    const base = ["/assets/*", "/_worker.js"];
+    const room = CF_MAX_RULES - base.length;
+    const exclude = [...base, ...prerendered.slice(0, room)];
+    if (prerendered.length > room) {
+      console.warn(
+        `  fluixi: ${prerendered.length} prerendered routes exceed Cloudflare's ${CF_MAX_RULES}-rule limit for _routes.json; ${prerendered.length - room} will invoke the worker to serve a static file.`
+      );
+    }
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(ctx.clientDir, "_routes.json"),
+      JSON.stringify({ version: 1, include: ["/*"], exclude }, null, 2) + "\n"
+    );
+  }
+};
+var netlifyAdapter = {
+  name: "netlify",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    if (skipWhenStatic(ctx, "netlify")) return appendRedirect(ctx.clientDir, SPA_FALLBACK);
+    const dir = (0, import_node_path2.join)(ctx.root, ".netlify", "functions-internal");
+    await (0, import_promises2.mkdir)(dir, { recursive: true });
+    const out = (0, import_node_path2.join)(dir, "fluixi-server.mjs");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(netlifyEntry(await entrySource(ctx, out, prerendered)), out);
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(dir, "fluixi-server.json"),
+      JSON.stringify({ config: { path: "/*", preferStatic: true }, version: 1 }, null, 2) + "\n"
+    );
+    if (!prerendered.includes("/")) {
+      await appendRedirect(ctx.clientDir, "/  /.netlify/functions/fluixi-server  200!");
+    }
+  }
+};
+var vercelAdapter = {
+  name: "vercel",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    const output = (0, import_node_path2.join)(ctx.root, ".vercel", "output");
+    await (0, import_promises2.mkdir)(output, { recursive: true });
+    await (0, import_promises2.cp)(ctx.clientDir, (0, import_node_path2.join)(output, "static"), { recursive: true });
+    if (skipWhenStatic(ctx, "vercel")) {
+      await (0, import_promises2.writeFile)(
+        (0, import_node_path2.join)(output, "config.json"),
+        JSON.stringify(
+          {
+            version: 3,
+            // The filesystem phase alone answers 404 for a client route, since nothing
+            // is on disk at that path; the catch-all is what makes it a SPA.
+            routes: [{ handle: "filesystem" }, { src: "/(.*)", dest: "/index.html" }]
+          },
+          null,
+          2
+        ) + "\n"
+      );
+      return;
+    }
+    const fn = (0, import_node_path2.join)(output, "functions", "index.func");
+    await (0, import_promises2.mkdir)(fn, { recursive: true });
+    const out = (0, import_node_path2.join)(fn, "index.mjs");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(vercelEntry(await entrySource(ctx, out, prerendered)), out);
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(fn, ".vc-config.json"),
+      JSON.stringify(
+        { runtime: "nodejs20.x", handler: "index.mjs", launcherType: "Nodejs", shouldAddHelpers: false },
+        null,
+        2
+      ) + "\n"
+    );
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(output, "config.json"),
+      JSON.stringify(
+        {
+          version: 3,
+          routes: [
+            // The filesystem holds a shell at `/index.html`, so `/` has to be claimed
+            // before that phase or it is served unrendered. Skipped when `/` really is
+            // a prerendered page, which the filesystem should answer.
+            ...prerendered.includes("/") ? [] : [{ src: "/", dest: "/index" }],
+            // A prerendered page or an asset wins; only a miss reaches the function.
+            { handle: "filesystem" },
+            { src: "/(.*)", dest: "/index" }
+          ]
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloudflareAdapter,
+  netlifyAdapter,
+  vercelAdapter
+});