@kasperrt/smolter 0.3.1 → 0.3.2

package/dist/core/responses.js

@@ -19,7 +19,7 @@ function redirect(location, init = 302) {
 function isRouteErrorResponse(value) {
 	return value instanceof Error && "status" in value;
 }
-async function normalizeResult(value) {
+async function normalizeResult(value, resolveDeferred = true) {
 	if (value && typeof value === "object" && "__routeError" in value) {
 		const error = value.__routeError;
 		return Object.assign(Error(error.message), error);
@@ -32,8 +32,8 @@ async function normalizeResult(value) {
 		});
 		return value.json();
 	}
-	if (value && typeof value === "object" && "__routeData" in value) return resolveData(value.value);
-	return resolveData(value);
+	if (value && typeof value === "object" && "__routeData" in value) return resolveDeferred ? resolveData(value.value) : value.value;
+	return resolveDeferred ? resolveData(value) : value;
 }
 async function resolveData(value) {
 	const resolved = await value;

package/dist/core/router.js

@@ -71,6 +71,7 @@ function createDataRouter(routes, options = {}) {
 				const fn = match.route[body ? "clientAction" : "clientLoader"] || match.route[body ? "action" : "loader"];
 				if (!fn) return body && Error("No action");
 				return fn({
+					reason: body ? "action" : navigation !== void 0 ? "navigation" : local ? "fetcher" : previous.loaded ? "revalidation" : "initial",
 					request: new Request(url, {
 						signal,
 						method: body && method,
@@ -84,6 +85,21 @@ function createDataRouter(routes, options = {}) {
 			const redirectTo = result.data instanceof Response && result.data.headers.get("Location");
 			if (redirectTo && redirects) {
 				await main.load(new URL(redirectTo, url).href, void 0, { replace: true }, true, redirects - 1);
+				if (body) {
+					const destination = new URL(main.getSnapshot().url);
+					const args = {
+						url: destination,
+						currentUrl: destination,
+						nextUrl: destination,
+						defaultShouldRevalidate: true,
+						reason: "action",
+						formMethod: method,
+						formAction: url.href,
+						formData: body,
+						actionResult: result.data
+					};
+					await Promise.all([...revalidators].filter((task) => task !== main).map((task) => task.revalidate(args)));
+				}
 				if (!signal.aborted) {
 					submission = void 0;
 					emit("idle");

package/dist/core/types.d.ts

@@ -6,6 +6,8 @@
 export type Params = Record<string, string>;
 /** Request, path parameters, and cancellation signal passed to a data handler. */
 export interface DataArgs {
+    /** Why this handler ran; independent of when browser history is committed. */
+    reason?: "initial" | "navigation" | "revalidation" | "fetcher" | "action";
     request: Request;
     params: Params;
     signal: AbortSignal;

package/dist/preact/client.d.ts

@@ -1,7 +1,12 @@
 /** Browser mounting and hydration for Preact applications. @module */
 /** @jsxImportSource preact */
+import { type DeploymentOptions } from "../client/index.ts";
 import { type Router } from "../core/index.ts";
 import type { AppRoute, RootModule } from "./route-types.ts";
 export * from "../client/index.ts";
 export { configureApplication } from "../core/environment.ts";
-export declare function mountApplication(routes: AppRoute[], rootModule?: RootModule, hash?: boolean): Promise<Router>;
+export interface MountApplicationOptions {
+    hash?: boolean;
+    deployment?: DeploymentOptions | null;
+}
+export declare function mountApplication(routes: AppRoute[], rootModule?: RootModule, options?: boolean | MountApplicationOptions): Promise<Router>;

package/dist/preact/client.js

@@ -6,7 +6,7 @@ import { connectNavigation } from "../core/navigation.js";
 import { attachRootData } from "./root-data.js";
 import { RouterApplication, prepareRoutes } from "./router.js";
 import { deserialize } from "../client/deserialize.js";
-import { watchDeployment } from "../client/deployment.js";
+import { recoverDeployment, watchDeployment } from "../client/deployment.js";
 import { serverRoute } from "../client/index.js";
 import { flushSync } from "preact/compat";
 import { jsx } from "preact/jsx-runtime";
@@ -14,20 +14,31 @@ import { hydrate, render } from "preact";
 //#region .generated/preact/client.tsx
 /** Browser mounting and hydration for Preact applications. @module */
 /** @jsxImportSource preact */
-async function mountApplication(routes, rootModule, hash = false) {
+async function mountApplication(routes, rootModule, options = false) {
+	const { hash = false, deployment = null } = typeof options === "boolean" ? { hash: options } : options;
 	const initialURL = new URL(hash ? location.hash.slice(1) || "/" : location.href, location.origin);
-	await (matchRoutes(routes, initialURL.pathname)?.route)?.preload?.();
+	await (matchRoutes(routes, initialURL.pathname)?.route)?.preload?.().catch(async (error) => {
+		await recoverDeployment(deployment, initialURL);
+		throw error;
+	});
 	routes = prepareRoutes(routes);
 	const element = document.getElementById("smolter-data");
-	const hydration = element?.textContent ? JSON.parse(element.textContent) : void 0;
+	const hydration = element?.textContent ? JSON.parse(element.textContent, (_key, value) => {
+		if (!value || typeof value !== "object" || !("__smolterRejected" in value)) return value;
+		const error = Object.assign(new Error(value.__smolterRejected.message), value.__smolterRejected);
+		const rejected = Promise.reject(error);
+		rejected.catch(() => {});
+		return rejected;
+	}) : void 0;
 	if (hydration?.snapshot.error) hydration.snapshot.error = Object.assign(new Error(hydration.snapshot.error.message), hydration.snapshot.error);
 	const router = createDataRouter(routes, {
 		browser: !hash,
 		url: hash ? new URL(location.hash.slice(1) || "/", location.origin).href : location.href,
 		...hydration && { hydrationData: hydration.snapshot }
 	});
-	retainRoute(router, flushSync);
+	watchDeployment(router, deployment);
 	if (hash) connectHashHistory(router);
+	retainRoute(router, flushSync);
 	connectNavigation(router);
 	const rootStore = attachRootData(router, hydration?.root, rootModule);
 	const props = {
@@ -35,7 +46,8 @@ async function mountApplication(routes, rootModule, hash = false) {
 		router,
 		root: hydration?.root,
 		rootModule,
-		rootStore
+		rootStore,
+		rootError: hydration?.rootError
 	};
 	if (hydration) {
 		hydrate(/* @__PURE__ */ jsx(RouterApplication, {
@@ -49,20 +61,27 @@ async function mountApplication(routes, rootModule, hash = false) {
 	return router;
 }
 function connectHashHistory(router) {
+	const read = router.getSnapshot;
 	const navigate = router.navigate;
 	router.navigate = async (url, options) => {
 		const target = new URL(url, router.getSnapshot().url);
-		const hash = `#${target.pathname}${target.search}`;
+		const hash = `#${target.pathname}${target.search}${target.hash}`;
 		history[options?.replace ? "replaceState" : "pushState"](null, "", hash);
 		await navigate(url, options);
 	};
+	const unsubscribe = router.subscribe(() => {
+		const target = new URL(read().url);
+		const hash = `#${target.pathname}${target.search}${target.hash}`;
+		if (location.hash !== hash) history.replaceState(history.state, "", hash);
+	});
 	const onHashChange = () => void navigate(location.hash.slice(1) || "/");
 	window.addEventListener("hashchange", onHashChange);
 	const dispose = router.dispose;
 	router.dispose = () => {
+		unsubscribe();
 		window.removeEventListener("hashchange", onHashChange);
 		dispose();
 	};
 }
 //#endregion
-export { configureApplication, deserialize, mountApplication, serverRoute, watchDeployment };
+export { configureApplication, deserialize, mountApplication, recoverDeployment, serverRoute, watchDeployment };

package/dist/preact/document.js

@@ -44,8 +44,9 @@ function Links() {
 	return /* @__PURE__ */ jsx(Fragment$1, { children: rootModule?.links?.().map((props, index) => /* @__PURE__ */ jsx("link", { ...props }, index)) });
 }
 function Scripts({ nonce }) {
-	const { root, router, entry } = useApplication();
+	const { root, rootError, router, entry, streaming } = useApplication();
 	const [json] = useState(() => {
+		if (streaming) return "";
 		const current = router.getSnapshot();
 		const snapshot = {
 			...current,
@@ -57,7 +58,8 @@ function Scripts({ nonce }) {
 		};
 		return serializeData({
 			root,
-			snapshot
+			snapshot,
+			...rootError && { rootError }
 		});
 	});
 	return /* @__PURE__ */ jsxs(Fragment$1, { children: [

package/dist/preact/lazy-route.d.ts

@@ -3,6 +3,7 @@ import { type ComponentType } from "preact";
 import type { AppRoute } from "./route-types.ts";
 export interface LazyRouteOptions {
     path: string;
+    dataEndpoint?: string;
     id?: string;
     loader?: boolean;
     action?: boolean;

package/dist/preact/lazy-route.js

@@ -16,7 +16,8 @@ function lazyRoute(options, importer) {
 		pending ??= importer().then((loaded) => {
 			module = serverRoute(options.path, loaded, {
 				loader: options.loader,
-				action: options.action
+				action: options.action,
+				dataEndpoint: options.dataEndpoint
 			});
 		}).catch((error) => {
 			pending = void 0;

package/dist/preact/root-context.d.ts

@@ -4,6 +4,8 @@ export interface ApplicationContext {
     router: Router;
     routes: AppRoute[];
     root: unknown;
+    rootError?: boolean;
+    streaming?: boolean;
     rootModule?: RootModule;
     hydration?: Hydration;
     entry?: string;

package/dist/preact/route-types.d.ts

@@ -47,6 +47,7 @@ export interface RootModule {
     shouldRevalidate?: (args: RevalidationArgs) => boolean;
 }
 export interface Hydration {
+    rootError?: boolean;
     root: unknown;
     snapshot: Snapshot;
 }

package/dist/preact/router.d.ts

@@ -13,4 +13,4 @@ export interface ApplicationProps extends ApplicationContext {
     rootStore?: ReturnType<typeof createRootStore>;
 }
 export declare function RouterApplication(props: ApplicationProps): import("preact").JSX.Element;
-export declare function prepareRoutes(routes: AppRoute[]): AppRoute[];
+export declare function prepareRoutes(routes: AppRoute[], preserveDeferred?: boolean): AppRoute[];

package/dist/preact/router.js

@@ -21,7 +21,7 @@ function RouterApplication(props) {
 	const root = useSyncExternalStore(rootStore.subscribe, rootStore.getSnapshot);
 	const snapshot = useSyncExternalStore(props.router.subscribe, props.router.getSnapshot);
 	const route = props.routes.find((item) => item.path === snapshot.path);
-	const Root = snapshot.error && !route?.ErrorBoundary ? props.rootModule?.ErrorBoundary ?? Outlet : props.rootModule?.default ?? Outlet;
+	const Root = snapshot.error && (props.rootError || !route?.ErrorBoundary) ? props.rootModule?.ErrorBoundary ?? Outlet : props.rootModule?.default ?? Outlet;
 	const Layout = props.rootModule?.Layout;
 	const children = /* @__PURE__ */ jsx(Root, {});
 	return /* @__PURE__ */ jsx(RouterProvider, {
@@ -35,7 +35,7 @@ function RouterApplication(props) {
 		})
 	});
 }
-function prepareRoutes(routes) {
+function prepareRoutes(routes, preserveDeferred = false) {
 	return routes.map((route) => {
 		const wrapped = {
 			...route,
@@ -54,7 +54,7 @@ function prepareRoutes(routes) {
 		]) {
 			const handler = route[key];
 			if (!handler) continue;
-			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then(normalizeResult, normalizeResult);
+			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then((value) => normalizeResult(value, !preserveDeferred), (error) => normalizeResult(error, !preserveDeferred));
 		}
 		return wrapped;
 	});

package/dist/server/application.d.ts

@@ -1,4 +1,7 @@
 /** @jsxImportSource preact */
 import type { AppRoute, RootModule } from "../preact/route-types.ts";
-export declare function renderApplication(request: Request, routes: AppRoute[], rootModule: RootModule, entry: string): Promise<Response>;
+export interface RenderApplicationOptions {
+    nonce?: string;
+}
+export declare function renderApplication(request: Request, routes: AppRoute[], rootModule: RootModule, entry: string, options?: RenderApplicationOptions): Promise<Response>;
 export declare function dispatchRoute(request: Request, routes: AppRoute[], document?: boolean): Promise<Response>;

package/dist/server/application.js

@@ -1,13 +1,16 @@
+import { safeWrapAsync } from "../core/errors.js";
 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 { privateResponse } from "./private-response.js";
 import { loadRouter } from "./index.js";
+import { resolveHydration, streamDocument } from "./stream-document.js";
 import { jsx } from "preact/jsx-runtime";
-import { renderToStringAsync } from "preact-render-to-string";
+import { renderToReadableStream } from "preact-render-to-string/stream";
 //#region .generated/server/application.tsx
 /** @jsxImportSource preact */
-async function renderApplication(request, routes, rootModule, entry) {
+async function renderApplication(request, routes, rootModule, entry, options = {}) {
 	routes = routes.map((route) => ({
 		...route,
 		path: route.routePath ?? route.path
@@ -21,16 +24,16 @@ async function renderApplication(request, routes, rootModule, entry) {
 		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?.({
+	const rootResult = safeWrapAsync(() => Promise.resolve().then(() => rootModule.loader?.({
 		request,
 		params: {},
 		signal: request.signal
-	}));
+	})).then((value) => normalizeResult(value, false), (error) => error instanceof Response ? normalizeResult(error, false) : error instanceof Error ? error : new Error(String(error), { cause: error })));
 	let redirectResponse;
 	const prepared = prepareRoutes(routes.map((route) => ({
 		...route,
 		ErrorBoundary: route.ErrorBoundary ?? rootModule.ErrorBoundary
-	}))).map((route) => {
+	})), true).map((route) => {
 		if (!route.loader) return route;
 		const loader = route.loader;
 		return {
@@ -42,41 +45,68 @@ async function renderApplication(request, routes, rootModule, entry) {
 			}
 		};
 	});
-	let router = await loadRouter(prepared, request);
+	const [rootState, loadedRouter] = await Promise.all([rootResult, loadRouter(prepared, request)]);
+	let router = loadedRouter;
+	const rootError = rootState.error ?? (rootState.data instanceof Error ? rootState.data : void 0);
+	const root = rootError ? void 0 : rootState.data;
+	if (root instanceof Response && root.headers.has("Location")) {
+		router.dispose();
+		return root;
+	}
 	if (redirectResponse) {
 		router.dispose();
 		return redirectResponse;
 	}
-	if (actionResponse) {
+	if (actionResponse || rootError) {
 		const hydrationData = {
 			...router.getSnapshot(),
 			actionData: actionData instanceof Error ? void 0 : actionData,
-			...actionData instanceof Error && { error: actionData }
+			...actionData instanceof Error && { error: actionData },
+			...rootError && { error: rootError }
 		};
 		router.dispose();
 		router = createDataRouter(router.routes, { hydrationData });
 	}
 	const snapshot = router.getSnapshot();
-	const html = await renderToStringAsync(/* @__PURE__ */ jsx(RouterApplication, {
+	const stream = renderToReadableStream(/* @__PURE__ */ jsx(RouterApplication, {
 		router,
 		routes,
 		root,
 		rootModule,
 		entry,
+		rootError: Boolean(rootError),
+		streaming: true,
 		document: true
-	}));
-	router.dispose();
+	}), options);
+	const hydration = resolveHydration({
+		root,
+		snapshot: {
+			...snapshot,
+			error: snapshot.error && {
+				...snapshot.error,
+				name: snapshot.error.name,
+				message: snapshot.error.message
+			}
+		},
+		...rootError && { rootError: true }
+	});
+	stream.allReady.catch(() => {});
 	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}`, {
+	return new Response(streamDocument(stream, {
+		hydration,
+		signal: request.signal,
+		nonce: options.nonce,
+		dispose: () => router.dispose()
+	}), {
 		status: snapshot.error ? Number("status" in snapshot.error ? snapshot.error.status : 500) : actionResponse?.status ?? 200,
 		headers
 	});
 }
-async function dispatchRoute(request, routes, document = false) {
+async function dispatch(request, routes, document = false) {
 	const match = matchRoutes(routes.map((route) => ({
 		...route,
 		path: route.routePath ?? route.path
@@ -115,5 +145,9 @@ async function dispatchRoute(request, routes, document = false) {
 	}
 	return Response.json(await normalizeResult(value) ?? null);
 }
+async function dispatchRoute(request, routes, document = false) {
+	const response = await dispatch(request, routes, document);
+	return document ? response : privateResponse(response);
+}
 //#endregion
 export { dispatchRoute, renderApplication };

package/dist/server/handler.d.ts

@@ -8,6 +8,8 @@ export interface RequestHandlerOptions {
     build: ServerBuild;
     /** Browser entry URL resolved from Vite's production manifest. */
     entry: string;
+    /** Must match the browser and Vite transport endpoint. */
+    dataEndpoint?: string;
 }
 export interface ServerIncomingMessage extends IncomingMessage {
     /** Express supplies this using the application's trust proxy policy. */
@@ -16,4 +18,4 @@ export interface ServerIncomingMessage extends IncomingMessage {
 }
 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>;
+export declare function createRequestHandler({ build, entry, dataEndpoint, }: RequestHandlerOptions): (incoming: ServerIncomingMessage, outgoing: ServerResponse, next: NextHandler) => Promise<void>;

package/dist/server/handler.js

@@ -1,11 +1,13 @@
+import { privateResponse } from "./private-response.js";
 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 }) {
+function createRequestHandler({ build, entry, dataEndpoint = "/_smolter" }) {
 	return (incoming, outgoing, next) => {
 		const handle = async () => {
 			const url = new URL(incoming.originalUrl ?? incoming.url ?? "/", "http://local");
-			const dataRequest = url.pathname === "/_smolter";
+			const dataRequest = url.pathname === dataEndpoint;
+			if (dataRequest) outgoing.setHeader("Cache-Control", "private, no-store");
 			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);
@@ -13,7 +15,7 @@ function createRequestHandler({ build, entry }) {
 			}
 			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);
+			await send(dataRequest ? privateResponse(response) : response, outgoing);
 		};
 		return handle().catch(next);
 	};

package/dist/server/http.d.ts

@@ -1,4 +1,8 @@
 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>;
+interface StreamingResponse extends ServerResponse {
+    flush?: () => void;
+}
+export declare function send(response: Response, outgoing: StreamingResponse): Promise<void>;
+export {};

package/dist/server/http.js

@@ -1,3 +1,5 @@
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
 //#region .generated/server/http.ts
 async function webRequest(incoming, outgoing, target) {
 	const origin = `${incoming.protocol ?? "http"}://${incoming.headers.host}`;
@@ -21,7 +23,14 @@ async function send(response, outgoing) {
 	});
 	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()));
+	if (!response.body) {
+		outgoing.end();
+		return;
+	}
+	await pipeline(Readable.fromWeb(response.body), new Transform({ transform(chunk, _encoding, done) {
+		done(null, chunk);
+		outgoing.flush?.();
+	} }), outgoing);
 }
 //#endregion
 export { send, webRequest };

package/dist/server/index.d.ts

@@ -6,5 +6,5 @@ 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>;
 export { serialize } from "../core/index.ts";
-/** Dispatch an HTTP data request to a registered server loader or action. */
+/** Dispatch a server data request with an explicit private cache policy. */
 export declare function handleRequest(routes: readonly Route[], request: Request): Promise<Response>;

package/dist/server/index.js

@@ -2,6 +2,7 @@ import { safeWrapAsync } from "../core/errors.js";
 import { matchRoutes } from "../core/match.js";
 import { createDataRouter } from "../core/router.js";
 import { serialize } from "../core/serialize.js";
+import { privateResponse } from "./private-response.js";
 //#region .generated/server/index.ts
 /**
 * Request-scoped server rendering and HTTP data dispatch.
@@ -46,7 +47,7 @@ async function loadRouter(routes, input) {
 	return router;
 }
 /** Dispatch an HTTP data request to a registered server loader or action. */
-async function handleRequest(routes, request) {
+async function dispatchRequest(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 });
@@ -67,10 +68,19 @@ async function handleRequest(routes, request) {
 	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 } });
+		if (location) {
+			const headers = new Headers(result.data.headers);
+			headers.delete("Location");
+			headers.set("X-Smolter-Redirect", location);
+			return new Response(null, { headers });
+		}
 		return result.data;
 	}
 	return Response.json(result.data ?? null, { headers: { "Cache-Control": "no-store" } });
 }
+/** Dispatch a server data request with an explicit private cache policy. */
+async function handleRequest(routes, request) {
+	return privateResponse(await dispatchRequest(routes, request));
+}
 //#endregion
 export { handleRequest, loadRouter, serialize };

package/dist/server/preact.d.ts

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

package/dist/server/private-response.d.ts

@@ -0,0 +1,2 @@
+/** Transport data must not be cached by shared intermediaries or the browser. */
+export declare function privateResponse(response: Response): Response;

package/dist/server/private-response.js

@@ -0,0 +1,13 @@
+//#region .generated/server/private-response.ts
+/** Transport data must not be cached by shared intermediaries or the browser. */
+function privateResponse(response) {
+	const headers = new Headers(response.headers);
+	headers.set("Cache-Control", "private, no-store");
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { privateResponse };

package/dist/server/stream-document.d.ts

@@ -0,0 +1,9 @@
+export declare function resolveHydration(value: unknown): Promise<unknown>;
+export interface StreamDocumentOptions {
+    hydration: Promise<unknown>;
+    nonce?: string;
+    signal: AbortSignal;
+    dispose: () => void;
+}
+/** Stream the shell immediately, then finalize the JSON snapshot before module scripts execute. */
+export declare function streamDocument(source: ReadableStream<Uint8Array>, options: StreamDocumentOptions): ReadableStream<Uint8Array>;

package/dist/server/stream-document.js

@@ -0,0 +1,78 @@
+import { serializeData } from "../core/serialize.js";
+//#region .generated/server/stream-document.ts
+async function resolveHydration(value) {
+	if (value instanceof Promise) return value.then(resolveHydration, (error) => ({ __smolterRejected: { message: error instanceof Error ? error.message : String(error) } }));
+	if (Array.isArray(value)) return Promise.all(value.map(resolveHydration));
+	if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+		const entries = await Promise.all(Object.entries(value).map(async ([key, field]) => [key, await resolveHydration(field)]));
+		return Object.fromEntries(entries);
+	}
+	return value;
+}
+/** Stream the shell immediately, then finalize the JSON snapshot before module scripts execute. */
+function streamDocument(source, options) {
+	const reader = source.getReader();
+	const encoder = new TextEncoder();
+	const decoder = new TextDecoder();
+	let suffix = "";
+	let first = true;
+	let cancelled = false;
+	let finish;
+	const interrupted = new Promise((resolve) => {
+		finish = resolve;
+	});
+	const abort = () => {
+		finish();
+		reader.cancel().catch(() => {});
+	};
+	options.signal.addEventListener("abort", abort, { once: true });
+	if (options.signal.aborted) abort();
+	function dispose() {
+		options.signal.removeEventListener("abort", abort);
+		options.dispose();
+	}
+	return new ReadableStream({
+		async pull(controller) {
+			const result = await reader.read().catch((error) => ({ error }));
+			if ("error" in result) {
+				dispose();
+				controller.error(result.error);
+				return;
+			}
+			if (result.done) {
+				if (!options.signal.aborted) {
+					const value = await Promise.race([options.hydration, interrupted]);
+					if (cancelled) return;
+					if (options.signal.aborted) {
+						dispose();
+						controller.close();
+						return;
+					}
+					const hydration = serializeData(value);
+					const nonce = options.nonce ? ` nonce="${options.nonce.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;")}"` : "";
+					controller.enqueue(encoder.encode(`<script type="application/json"${nonce}>${hydration}<\/script><script${nonce}>(function(){var script=document.currentScript,payload=script.previousElementSibling,data=document.getElementById("smolter-data");if(data)data.textContent=payload.textContent;payload.remove();script.remove()})()<\/script>${suffix}`));
+				}
+				dispose();
+				controller.close();
+				return;
+			}
+			let chunk = decoder.decode(result.value, { stream: true });
+			if (first && !/^<!doctype/i.test(chunk)) chunk = `<!doctype html>${chunk}`;
+			first = false;
+			const closing = chunk.lastIndexOf("</body>");
+			if (closing !== -1) {
+				suffix = chunk.slice(closing);
+				chunk = chunk.slice(0, closing);
+			}
+			controller.enqueue(encoder.encode(chunk));
+		},
+		async cancel() {
+			cancelled = true;
+			finish();
+			dispose();
+			await reader.cancel();
+		}
+	});
+}
+//#endregion
+export { resolveHydration, streamDocument };

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

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