@kasperrt/smolter 0.0.1 → 0.3.0

package/dist/server/application.js

@@ -0,0 +1,119 @@
+import { matchRoutes } from "../core/match.js";
+import { createDataRouter } from "../core/router.js";
+import { normalizeResult, resolveData } from "../core/responses.js";
+import { RouterApplication, prepareRoutes } from "../preact/router.js";
+import { loadRouter } from "./index.js";
+import { jsx } from "preact/jsx-runtime";
+import { renderToStringAsync } from "preact-render-to-string";
+//#region .generated/server/application.tsx
+/** @jsxImportSource preact */
+async function renderApplication(request, routes, rootModule, entry) {
+	routes = routes.map((route) => ({
+		...route,
+		path: route.routePath ?? route.path
+	}));
+	const match = matchRoutes(routes, new URL(request.url).pathname);
+	if (match && !match.route.default) return dispatchRoute(request, routes, true);
+	let actionResponse;
+	let actionData;
+	if (request.method !== "GET" && request.method !== "HEAD") {
+		actionResponse = await dispatchRoute(request, routes, true);
+		if (actionResponse.headers.has("Location") || !actionResponse.headers.get("Content-Type")?.includes("application/json")) return actionResponse;
+		actionData = await normalizeResult(await actionResponse.json());
+	}
+	const root = await resolveData(await rootModule.loader?.({
+		request,
+		params: {},
+		signal: request.signal
+	}));
+	let redirectResponse;
+	const prepared = prepareRoutes(routes.map((route) => ({
+		...route,
+		ErrorBoundary: route.ErrorBoundary ?? rootModule.ErrorBoundary
+	}))).map((route) => {
+		if (!route.loader) return route;
+		const loader = route.loader;
+		return {
+			...route,
+			loader: async (args) => {
+				const value = await loader(args);
+				if (value instanceof Response && value.headers.has("Location")) redirectResponse = value;
+				return value;
+			}
+		};
+	});
+	let router = await loadRouter(prepared, request);
+	if (redirectResponse) {
+		router.dispose();
+		return redirectResponse;
+	}
+	if (actionResponse) {
+		const hydrationData = {
+			...router.getSnapshot(),
+			actionData: actionData instanceof Error ? void 0 : actionData,
+			...actionData instanceof Error && { error: actionData }
+		};
+		router.dispose();
+		router = createDataRouter(router.routes, { hydrationData });
+	}
+	const snapshot = router.getSnapshot();
+	const html = await renderToStringAsync(/* @__PURE__ */ jsx(RouterApplication, {
+		router,
+		routes,
+		root,
+		rootModule,
+		entry,
+		document: true
+	}));
+	router.dispose();
+	const headers = new Headers(actionResponse?.headers);
+	headers.delete("Content-Length");
+	headers.delete("Content-Encoding");
+	headers.set("Content-Type", "text/html; charset=utf-8");
+	headers.set("Cache-Control", "no-store");
+	return new Response(`<!doctype html>${html}`, {
+		status: snapshot.error ? Number("status" in snapshot.error ? snapshot.error.status : 500) : actionResponse?.status ?? 200,
+		headers
+	});
+}
+async function dispatchRoute(request, routes, document = false) {
+	const match = matchRoutes(routes.map((route) => ({
+		...route,
+		path: route.routePath ?? route.path
+	})), new URL(request.url).pathname);
+	if (!match) return Response.json({ error: "No route" }, { status: 404 });
+	const handler = request.method === "GET" || request.method === "HEAD" ? match.route.loader : match.route.action;
+	if (!handler) return Response.json({ error: "No handler" }, { status: 405 });
+	const value = await Promise.resolve().then(() => handler({
+		request,
+		params: match.params,
+		signal: request.signal
+	})).then((result) => result, (error) => error);
+	if (value instanceof Response) {
+		const location = value.headers.get("Location");
+		if (document) return value;
+		if (!location) {
+			if (value.ok) return value;
+			return Response.json({ __routeError: {
+				message: await value.text(),
+				status: value.status,
+				statusText: value.statusText
+			} });
+		}
+		const headers = new Headers(value.headers);
+		headers.delete("Location");
+		headers.set("X-Smolter-Redirect", location);
+		return new Response(null, { headers });
+	}
+	if (value instanceof Error) return Response.json({ __routeError: {
+		...value,
+		message: value.message
+	} });
+	if (value && typeof value === "object" && "__routeData" in value) {
+		const result = value;
+		return Response.json(await resolveData(result.value), document ? result.init : { headers: result.init.headers });
+	}
+	return Response.json(await normalizeResult(value) ?? null);
+}
+//#endregion
+export { dispatchRoute, renderApplication };

package/dist/server/assets.d.ts

@@ -0,0 +1,5 @@
+export interface RouteAssets {
+    path: string;
+    files: string[];
+}
+export declare function routePreloads(routes: RouteAssets[], pathname: string, base: string): string;

package/dist/server/assets.js

@@ -0,0 +1,7 @@
+import { matchRoutes } from "../core/match.js";
+//#region .generated/server/assets.ts
+function routePreloads(routes, pathname, base) {
+	return ((matchRoutes(routes, pathname)?.route)?.files ?? []).map((file) => `<${base.replace(/\/$/, "")}/${file}>; rel=modulepreload`).join(", ");
+}
+//#endregion
+export { routePreloads };

package/dist/server/handler.d.ts

@@ -0,0 +1,19 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/** Server module produced by an application's SSR entrypoint. */
+export interface ServerBuild {
+    default: (request: Request, entry: string) => Response | Promise<Response>;
+    handleDataRequest: (request: Request) => Response | Promise<Response>;
+}
+export interface RequestHandlerOptions {
+    build: ServerBuild;
+    /** Browser entry URL resolved from Vite's production manifest. */
+    entry: string;
+}
+export interface ServerIncomingMessage extends IncomingMessage {
+    /** Express supplies this using the application's trust proxy policy. */
+    protocol?: string;
+    originalUrl?: string;
+}
+export type NextHandler = (error?: unknown) => void;
+/** Node/Express middleware; mount after metrics, tracing and static assets. */
+export declare function createRequestHandler({ build, entry, }: RequestHandlerOptions): (incoming: ServerIncomingMessage, outgoing: ServerResponse, next: NextHandler) => Promise<void>;

package/dist/server/handler.js

@@ -0,0 +1,22 @@
+import { send, webRequest } from "./http.js";
+//#region .generated/server/handler.ts
+/** Node/Express middleware; mount after metrics, tracing and static assets. */
+function createRequestHandler({ build, entry }) {
+	return (incoming, outgoing, next) => {
+		const handle = async () => {
+			const url = new URL(incoming.originalUrl ?? incoming.url ?? "/", "http://local");
+			const dataRequest = url.pathname === "/_smolter";
+			const target = dataRequest ? url.searchParams.get("url") : void 0;
+			if (dataRequest && (!target?.startsWith("/") || new URL(target, "http://local").origin !== "http://local")) {
+				await send(new Response("Invalid route URL", { status: 400 }), outgoing);
+				return;
+			}
+			const request = await webRequest(incoming, outgoing, target ?? void 0);
+			const response = dataRequest ? await build.handleDataRequest(request) : await build.default(request, entry);
+			await send(response, outgoing);
+		};
+		return handle().catch(next);
+	};
+}
+//#endregion
+export { createRequestHandler };

package/dist/server/http.d.ts

@@ -0,0 +1,4 @@
+import type { ServerResponse } from "node:http";
+import type { ServerIncomingMessage } from "./handler.ts";
+export declare function webRequest(incoming: ServerIncomingMessage, outgoing: ServerResponse, target?: string): Promise<Request>;
+export declare function send(response: Response, outgoing: ServerResponse): Promise<void>;

package/dist/server/http.js

@@ -0,0 +1,27 @@
+//#region .generated/server/http.ts
+async function webRequest(incoming, outgoing, target) {
+	const origin = `${incoming.protocol ?? "http"}://${incoming.headers.host}`;
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(incoming.headers)) if (value) headers.set(name, Array.isArray(value) ? value.join(", ") : value);
+	const controller = new AbortController();
+	outgoing.once("close", () => controller.abort());
+	const chunks = [];
+	for await (const chunk of incoming) chunks.push(chunk);
+	return new Request(new URL(target ?? incoming.originalUrl ?? incoming.url ?? "/", origin), {
+		method: incoming.method,
+		headers,
+		signal: controller.signal,
+		...incoming.method !== "GET" && incoming.method !== "HEAD" && { body: new Uint8Array(Buffer.concat(chunks)) }
+	});
+}
+async function send(response, outgoing) {
+	outgoing.statusCode = response.status;
+	response.headers.forEach((value, name) => {
+		if (name !== "set-cookie") outgoing.setHeader(name, value);
+	});
+	const cookies = response.headers.getSetCookie();
+	if (cookies.length) outgoing.setHeader("set-cookie", cookies.map((cookie) => process.env.NODE_ENV === "production" ? cookie : cookie.replace(/; Secure/gi, "")));
+	outgoing.end(new Uint8Array(await response.arrayBuffer()));
+}
+//#endregion
+export { send, webRequest };

package/dist/{internal/server → server}/index.d.ts

@@ -2,10 +2,9 @@
  * Request-scoped server rendering and HTTP data dispatch.
  * @module
  */
-import { type Route, type Router, type Snapshot } from "../core/index.ts";
+import { type Route, type Router } from "../core/index.ts";
 /** Create one router per server request, await this, then render the provider. */
 export declare function loadRouter(routes: readonly Route[], input: string | Request): Promise<Router>;
-/** Safe inside a script element. Data must be JSON serializable; error stacks and causes are omitted. */
-export declare function serialize(snapshot: Snapshot): string;
+export { serialize } from "../core/index.ts";
 /** Dispatch an HTTP data request to a registered server loader or action. */
 export declare function handleRequest(routes: readonly Route[], request: Request): Promise<Response>;

package/dist/server/index.js

@@ -0,0 +1,76 @@
+import { safeWrapAsync } from "../core/errors.js";
+import { matchRoutes } from "../core/match.js";
+import { createDataRouter } from "../core/router.js";
+import { serialize } from "../core/serialize.js";
+//#region .generated/server/index.ts
+/**
+* Request-scoped server rendering and HTTP data dispatch.
+* @module
+*/
+/** Create one router per server request, await this, then render the provider. */
+async function loadRouter(routes, input) {
+	const url = typeof input === "string" ? input : input.url;
+	const wrap = (handler) => {
+		if (!handler || typeof input === "string") return handler;
+		return (args) => {
+			const signal = AbortSignal.any([input.signal, args.signal]);
+			const request = new Request(args.request, { signal });
+			input.headers.forEach((value, name) => {
+				if (!request.headers.has(name)) request.headers.set(name, value);
+			});
+			return handler({
+				...args,
+				request,
+				signal
+			});
+		};
+	};
+	const serverRoutes = routes.map((route) => ({
+		...route,
+		clientLoader: void 0,
+		clientAction: void 0,
+		loader: wrap(route.loader),
+		action: wrap(route.action)
+	}));
+	const router = createDataRouter(serverRoutes, { url });
+	await router.navigate(url);
+	const snapshot = router.getSnapshot();
+	if (!snapshot.error && snapshot.data === void 0 && routes.some((route) => route.path === snapshot.path && route.clientLoader && !route.loader)) return createDataRouter(serverRoutes, {
+		url,
+		hydrationData: {
+			...snapshot,
+			loaded: false,
+			state: "loading"
+		}
+	});
+	return router;
+}
+/** Dispatch an HTTP data request to a registered server loader or action. */
+async function handleRequest(routes, request) {
+	const match = matchRoutes(routes, new URL(request.url).pathname);
+	const reading = request.method === "GET";
+	if (!match) return Response.json({ error: "No route" }, { status: 404 });
+	if (!reading && ![
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	].includes(request.method)) return Response.json({ error: "Method not allowed" }, { status: 405 });
+	const handler = reading ? match.route.loader : match.route.action;
+	if (!handler) return Response.json({ error: `No ${reading ? "loader" : "action"}` }, { status: 405 });
+	const result = await safeWrapAsync(() => handler({
+		request,
+		params: match.params,
+		signal: request.signal
+	}));
+	const error = result.error ?? (result.data instanceof Error && result.data);
+	if (error) return Response.json({ error: error.message }, { status: 500 });
+	if (result.data instanceof Response) {
+		const location = result.data.headers.get("Location");
+		if (location) return new Response(null, { headers: { "X-Smolter-Redirect": location } });
+		return result.data;
+	}
+	return Response.json(result.data ?? null, { headers: { "Cache-Control": "no-store" } });
+}
+//#endregion
+export { handleRequest, loadRouter, serialize };

package/dist/server/node.d.ts

@@ -0,0 +1,3 @@
+/** Optional application integration. @module */
+export * from "./handler.ts";
+export * from "./http.ts";

package/dist/server/node.js

@@ -0,0 +1,3 @@
+import { send, webRequest } from "./http.js";
+import { createRequestHandler } from "./handler.js";
+export { createRequestHandler, send, webRequest };

package/dist/server/preact.d.ts

@@ -0,0 +1,3 @@
+/** Preact server rendering and HTTP data dispatch. @module */
+export { dispatchRoute, renderApplication, } from "./application.tsx";
+export * from "./index.ts";

package/dist/server/preact.js

@@ -0,0 +1,4 @@
+import { serialize } from "../core/serialize.js";
+import { handleRequest, loadRouter } from "./index.js";
+import { dispatchRoute, renderApplication } from "./application.js";
+export { dispatchRoute, handleRequest, loadRouter, renderApplication, serialize };

package/dist/vite/application/browser-boundary.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "vite";
+/** Check emitted modules, after tree shaking, rather than import strings. */
+export declare function browserBoundary(): Plugin;

package/dist/vite/application/browser-boundary.js

@@ -0,0 +1,35 @@
+import { builtinModules } from "node:module";
+//#region .generated/vite/application/browser-boundary.ts
+var builtins = new Set(builtinModules.flatMap((id) => [id, `node:${id}`]));
+var forbiddenModules = [
+	/(?:vite-browser-external|__vite-browser-external)/,
+	/\/node_modules\/(?:react|react-dom|react-router|react-router-dom)\//,
+	/\/smolter\/dist\/(?:internal\/)?(?:server|vite|files)\//,
+	/\/smolter\/packages\/(?:server|vite)\/src\//,
+	/\/vite\/dist\/node\//,
+	/\/src\/[^?]*\.server\.[cm]?[jt]sx?(?:\?|$)/
+];
+/** Check emitted modules, after tree shaking, rather than import strings. */
+function browserBoundary() {
+	return {
+		name: "smolter-browser-boundary",
+		apply: "build",
+		applyToEnvironment: (environment) => environment.name === "client",
+		generateBundle(_options, bundle) {
+			for (const output of Object.values(bundle)) {
+				if (output.type !== "chunk") continue;
+				for (const id of [...output.imports, ...output.dynamicImports]) {
+					if (!builtins.has(id)) continue;
+					this.error(`Node builtin in browser chunk ${output.fileName}: ${id}`);
+				}
+				for (const id of Object.keys(output.modules)) {
+					const normalized = id.replaceAll("\\", "/");
+					if (!forbiddenModules.some((pattern) => pattern.test(normalized))) continue;
+					this.error(`Unexpected browser module in ${output.fileName}: ${id}`);
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { browserBoundary };

package/dist/vite/application/lazy-files.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare function lazyFiles(directory: string): Plugin;

package/dist/vite/application/lazy-files.js

@@ -0,0 +1,87 @@
+import { flatRoutes } from "../../files/index.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { transformWithOxc } from "vite";
+//#region .generated/vite/application/lazy-files.ts
+function lazyFiles(directory) {
+	let root;
+	const modules = /* @__PURE__ */ new Map();
+	return {
+		name: "smolter-lazy-routes",
+		enforce: "pre",
+		configResolved(config) {
+			root = resolve(config.root, directory);
+		},
+		generateBundle(_options, bundle) {
+			if (!modules.size) return;
+			const routes = [];
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "chunk" || !chunk.facadeModuleId) continue;
+				const path = modules.get(chunk.facadeModuleId);
+				if (!path) continue;
+				const files = /* @__PURE__ */ new Set();
+				function visit(file) {
+					if (files.has(file)) return;
+					files.add(file);
+					const dependency = bundle[file];
+					if (dependency?.type !== "chunk") return;
+					for (const imported of dependency.imports) visit(imported);
+				}
+				visit(chunk.fileName);
+				routes.push({
+					path,
+					files: [...files]
+				});
+			}
+			const paths = [...modules.values()];
+			routes.sort((left, right) => paths.indexOf(left.path) - paths.indexOf(right.path));
+			this.emitFile({
+				type: "asset",
+				fileName: ".vite/route-assets.json",
+				source: JSON.stringify(routes)
+			});
+		},
+		async load(id, options) {
+			if (id !== "\0virtual:smolter/routes" || options?.ssr) return;
+			const routes = await flatRoutes(root);
+			if (routes instanceof Error) return this.error(routes.message);
+			const definitions = [];
+			for (const route of routes) {
+				this.addWatchFile(route.file);
+				const source = await readFile(route.file, "utf8");
+				const transformed = await transformWithOxc(source, route.file);
+				const ast = this.parse(transformed.code);
+				const fields = { path: route.path };
+				for (const statement of ast.body) {
+					if (statement.type === "ExportDefaultDeclaration") {
+						fields.default = true;
+						continue;
+					}
+					if (statement.type !== "ExportNamedDeclaration") continue;
+					if (statement.declaration?.type === "FunctionDeclaration") {
+						const name = statement.declaration.id?.name;
+						if (name) fields[name] = true;
+					}
+					for (const specifier of statement.specifiers) {
+						const name = specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value;
+						fields[name] = true;
+					}
+					if (statement.declaration?.type !== "VariableDeclaration") continue;
+					for (const declaration of statement.declaration.declarations) {
+						if (declaration.id.type === "Identifier") fields[declaration.id.name] = true;
+						if (declaration.id.type !== "Identifier" || declaration.init?.type !== "Literal" || typeof declaration.init.value !== "string") continue;
+						const name = declaration.id.name;
+						if (name === "id") fields.id = declaration.init.value;
+						if (name === "routePath") fields.path = declaration.init.value;
+					}
+				}
+				const file = `${route.file.replaceAll("\\", "/")}?smolter-client`;
+				if (fields.default) modules.set(file, String(fields.path));
+				definitions.push(`lazyRoute(${JSON.stringify(fields)}, () => import(${JSON.stringify(file)}))`);
+			}
+			return ["import { lazyRoute } from \"@kasperrt/smolter/preact/lazy-route\";", `export default [${definitions.join(",\n")}];`].join("\n");
+		}
+	};
+}
+//#endregion
+export { lazyFiles };

package/dist/vite/application/vite.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin, UserConfig } from "vite";
+export interface ApplicationOptions {
+    directory?: string;
+    ssr?: boolean;
+    splitRoutes?: boolean;
+    resourceRequest?: (url: string) => boolean;
+}
+export declare const preactConfig: UserConfig;
+export declare function applicationPlugins({ directory, ssr, splitRoutes, resourceRequest, }?: ApplicationOptions): Plugin[];

package/dist/vite/application/vite.js

@@ -0,0 +1,101 @@
+import { routerPlugin } from "../index.js";
+import { send, webRequest } from "../../server/http.js";
+import { browserBoundary } from "./browser-boundary.js";
+import { lazyFiles } from "./lazy-files.js";
+//#region .generated/vite/application/vite.ts
+var preactConfig = {
+	resolve: {
+		alias: [
+			{
+				find: /^react\/jsx-dev-runtime$/,
+				replacement: "preact/jsx-dev-runtime"
+			},
+			{
+				find: /^react\/jsx-runtime$/,
+				replacement: "preact/jsx-runtime"
+			},
+			{
+				find: /^react-dom\/client$/,
+				replacement: "preact/compat/client"
+			},
+			{
+				find: /^react-dom\/server$/,
+				replacement: "preact-render-to-string"
+			},
+			{
+				find: /^react-dom$/,
+				replacement: "preact/compat"
+			},
+			{
+				find: /^react$/,
+				replacement: "preact/compat"
+			}
+		],
+		dedupe: ["preact", "@kasperrt/smolter"]
+	},
+	ssr: { noExternal: ["@kasperrt/smolter"] },
+	optimizeDeps: { include: [
+		"preact",
+		"preact/hooks",
+		"preact/compat",
+		"preact/jsx-runtime",
+		"@kasperrt/smolter/preact",
+		"@kasperrt/smolter/preact/lazy-route"
+	] }
+};
+function applicationPlugins({ directory = "src/routes", ssr = true, splitRoutes = true, resourceRequest } = {}) {
+	return [
+		{
+			name: "smolter-application",
+			enforce: "pre",
+			config: () => preactConfig,
+			transformIndexHtml: {
+				order: "post",
+				handler(html, context) {
+					if (!context.server || !ssr) return html;
+					const client = html.match(/\s*<script\b[^>]*src="[^"]*\/@vite\/client"[^>]*><\/script>\s*/)?.[0];
+					if (!client) return html;
+					return html.replace(client, "").replace("</body>", `${client.trim()}</body>`);
+				}
+			},
+			configureServer(server) {
+				server.middlewares.use((incoming, outgoing, next) => {
+					if (!incoming.url?.startsWith("/_smolter?")) return next();
+					const run = async () => {
+						const target = new URL(incoming.url, "http://local").searchParams.get("url");
+						if (!target?.startsWith("/") || target.startsWith("//")) return send(new Response("Invalid route URL", { status: 400 }), outgoing);
+						const request = await webRequest(incoming, outgoing, target);
+						const [{ default: routes }, { dispatchRoute }] = await Promise.all([server.ssrLoadModule("virtual:smolter/routes"), server.ssrLoadModule("@kasperrt/smolter/preact/server")]);
+						await send(await dispatchRoute(request, routes), outgoing);
+					};
+					run().catch(next);
+				});
+				if (!ssr) return;
+				return () => {
+					server.middlewares.use((incoming, outgoing, next) => {
+						if (!incoming.headers.accept?.includes("text/html") && !resourceRequest?.(incoming.originalUrl ?? incoming.url ?? "")) return next();
+						const run = async () => {
+							const request = await webRequest(incoming, outgoing);
+							const response = await (await server.ssrLoadModule("/src/entry.server.tsx")).default(request, "/src/entry.client.tsx");
+							if (!response.headers.get("Content-Type")?.includes("text/html")) return send(response, outgoing);
+							const html = await server.transformIndexHtml(incoming.url, await response.text());
+							await send(new Response(html, {
+								status: response.status,
+								headers: response.headers
+							}), outgoing);
+						};
+						run().catch(next);
+					});
+				};
+			}
+		},
+		browserBoundary(),
+		...splitRoutes ? [lazyFiles(directory)] : [],
+		routerPlugin({
+			directory,
+			framework: "preact"
+		})
+	];
+}
+//#endregion
+export { applicationPlugins, preactConfig };

package/dist/{internal/vite → vite}/index.d.ts

@@ -3,8 +3,9 @@ export interface FileRouterOptions {
     directory?: string;
     clientRoutes?: string;
     serverRoutes?: string;
+    framework?: "react" | "preact";
 }
 /** Build-time flat route discovery and the optional server data transport. */
-export declare function routerPlugin({ directory, clientRoutes, serverRoutes, }?: FileRouterOptions): Plugin;
+export declare function routerPlugin({ directory, clientRoutes, serverRoutes, framework, }?: FileRouterOptions): Plugin;
 /** File routing is the default; this alias keeps configuration explicit. */
 export declare const fileRouter: typeof routerPlugin;