@sveltejs/kit 3.0.0-next.23 → 3.0.0-next.25

package/src/runtime/server/page/data_serializer.js

@@ -1,7 +1,7 @@
 import * as devalue from 'devalue';
 import { compact } from '../../../utils/array.js';
 import { create_async_iterator } from '../../../utils/streaming.js';
-import { clarify_devalue_error, get_global_name, serialize_uses } from '../utils.js';
+import { clarify_devalue_error, serialize_uses } from '../utils.js';
 import { handle_error_and_jsonify } from '../errors.js';
 import { encoders } from '#app/internal/transport';
 
@@ -10,15 +10,14 @@ import { encoders } from '#app/internal/transport';
  * async iterable containing their resolutions
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
  * @returns {import('./types.js').ServerDataSerializer}
  */
-export function server_data_serializer(event, state, options) {
+export function server_data_serializer(event, state) {
 	let promise_id = 1;
 	let max_nodes = -1;
 
 	const iterator = create_async_iterator();
-	const global = get_global_name(options);
+	const global = __SVELTEKIT_GLOBAL_NAME__;
 
 	/** @param {number} index */
 	function get_replacer(index) {
@@ -31,7 +30,7 @@ export function server_data_serializer(event, state, options) {
 					.then(/** @param {any} data */ (data) => ({ data }))
 					.catch(
 						/** @param {any} error */ async (error) => ({
-							error: await handle_error_and_jsonify(event, state, options, error)
+							error: await handle_error_and_jsonify(event, state, error)
 						})
 					)
 					.then(
@@ -46,7 +45,6 @@ export function server_data_serializer(event, state, options) {
 								error = await handle_error_and_jsonify(
 									event,
 									state,
-									options,
 									new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
 										cause: e
 									})
@@ -127,10 +125,9 @@ export function server_data_serializer(event, state, options) {
  * async iterable containing their resolutions
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
  * @returns {import('./types.js').ServerDataSerializerJson}
  */
-export function server_data_serializer_json(event, state, options) {
+export function server_data_serializer_json(event, state) {
 	let promise_id = 1;
 
 	const iterator = create_async_iterator();
@@ -152,7 +149,7 @@ export function server_data_serializer_json(event, state, options) {
 				.catch(
 					/** @param {any} e */ async (e) => {
 						key = 'error';
-						return handle_error_and_jsonify(event, state, options, /** @type {any} */ (e));
+						return handle_error_and_jsonify(event, state, /** @type {any} */ (e));
 					}
 				)
 				.then(
@@ -165,7 +162,6 @@ export function server_data_serializer_json(event, state, options) {
 							const error = await handle_error_and_jsonify(
 								event,
 								state,
-								options,
 								new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
 									cause: e
 								})

package/src/runtime/server/page/index.js

@@ -1,13 +1,12 @@
-/** @import { Component } from 'svelte' */
 /** @import { RequestEvent, SSRManifest } from '@sveltejs/kit' */
-/** @import { ActionResult } from '$app/forms' */
-/** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRNode, SSROptions } from 'types' */
+/** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRNode } from 'types' */
 import { text } from '@sveltejs/kit';
 import { Redirect } from '@sveltejs/kit/internal';
 import { compact } from '../../../utils/array.js';
 import { get_status, normalize_error } from '../../../utils/error.js';
 import { noop } from '../../../utils/functions.js';
 import { add_data_suffix } from '../../pathname.js';
+import { build_error_chain, nearest_error_pages } from '../../error-chain.js';
 import { redirect_response } from '../utils.js';
 import { static_error_page, handle_error_and_jsonify } from '../errors.js';
 import {
@@ -33,13 +32,12 @@ const MAX_DEPTH = 10;
  * @param {RequestEvent} event
  * @param {RequestState} state
  * @param {PageNodeIndexes} page
- * @param {SSROptions} options
  * @param {SSRManifest} manifest
  * @param {import('../../../utils/page_nodes.js').PageNodes} nodes
  * @param {RequiredResolveOptions} resolve_opts
  * @returns {Promise<Response>}
  */
-export async function render_page(event, state, page, options, manifest, nodes, resolve_opts) {
+export async function render_page(event, state, page, manifest, nodes, resolve_opts) {
 	if (state.depth > MAX_DEPTH) {
 		// infinite request cycle detected
 		return text(`Not found: ${event.url.pathname}`, {
@@ -49,7 +47,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 
 	if (is_action_json_request(event)) {
 		const node = await manifest._.nodes[page.leaf]();
-		return handle_action_json_request(event, state, options, node?.server);
+		return handle_action_json_request(event, state, node?.server);
 	}
 
 	try {
@@ -57,7 +55,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 
 		let status = 200;
 
-		/** @type {ActionResult | undefined} */
+		/** @type {import('types').ServerActionResult | undefined} */
 		let action_result = undefined;
 
 		if (is_action_request(event)) {
@@ -151,10 +149,9 @@ export async function render_page(event, state, page, options, manifest, nodes,
 				error: null,
 				event,
 				state,
-				options,
 				manifest,
 				resolve_opts,
-				data_serializer: server_data_serializer(event, state, options)
+				data_serializer: server_data_serializer(event, state)
 			});
 		}
 
@@ -164,10 +161,10 @@ export async function render_page(event, state, page, options, manifest, nodes,
 		/** @type {Error | null} */
 		let load_error = null;
 
-		const data_serializer = server_data_serializer(event, state, options);
+		const data_serializer = server_data_serializer(event, state);
 		const data_serializer_json =
 			(state.prerendering || state.prerender_default === true) && should_prerender_data
-				? server_data_serializer_json(event, state, options)
+				? server_data_serializer_json(event, state)
 				: null;
 
 		/** @type {Array<Promise<ServerDataNode | null>>} */
@@ -275,50 +272,43 @@ export async function render_page(event, state, page, options, manifest, nodes,
 						return redirect_response(err.status, err.location);
 					}
 
-					const error = await handle_error_and_jsonify(event, state, options, err);
+					const error = await handle_error_and_jsonify(event, state, err);
 					const status = error.status;
 
-					while (i--) {
-						if (page.errors[i]) {
-							const index = /** @type {number} */ (page.errors[i]);
-							const node = await manifest._.nodes[index]();
-
-							let j = i;
-							while (!branch[j]) j -= 1;
-
-							data_serializer.set_max_nodes(j + 1);
-
-							const layouts = compact(branch.slice(0, j + 1));
-							const nodes = new PageNodes(layouts.map((layout) => layout.node));
-							const error_branch = layouts.concat({
-								node,
-								data: null,
-								server_data: null
-							});
-
-							return await render_response({
-								event,
-								state,
-								options,
-								manifest,
-								resolve_opts,
-								page_config: {
-									ssr: nodes.ssr(),
-									csr: nodes.csr()
-								},
-								status,
-								error,
-								error_components: await load_error_components(ssr, error_branch, page, manifest),
-								branch: error_branch,
-								fetched,
-								data_serializer
-							});
-						}
+					for (const { error: index, idx } of nearest_error_pages(i, branch, page.errors)) {
+						const node = await manifest._.nodes[index]();
+
+						data_serializer.set_max_nodes(idx);
+
+						const layouts = compact(branch.slice(0, idx));
+						const nodes = new PageNodes(layouts.map((layout) => layout.node));
+						const error_branch = layouts.concat({
+							node,
+							data: null,
+							server_data: null
+						});
+
+						return await render_response({
+							event,
+							state,
+							manifest,
+							resolve_opts,
+							page_config: {
+								ssr: nodes.ssr(),
+								csr: nodes.csr()
+							},
+							status,
+							error,
+							error_components: await load_error_components(ssr, error_branch, page, manifest),
+							branch: error_branch,
+							fetched,
+							data_serializer
+						});
 					}
 
 					// if we're still here, it means the error happened in the root layout,
 					// which means we have to fall back to error.html
-					return static_error_page(options, status, error.message);
+					return static_error_page(status, error.message);
 				}
 			} else {
 				// push an empty slot so we can rewind past gaps to the
@@ -346,7 +336,6 @@ export async function render_page(event, state, page, options, manifest, nodes,
 		return await render_response({
 			event,
 			state,
-			options,
 			manifest,
 			resolve_opts,
 			page_config: {
@@ -358,7 +347,7 @@ export async function render_page(event, state, page, options, manifest, nodes,
 			branch: compact(branch),
 			action_result,
 			fetched,
-			data_serializer: !ssr ? server_data_serializer(event, state, options) : data_serializer,
+			data_serializer: !ssr ? server_data_serializer(event, state) : data_serializer,
 			error_components: await load_error_components(ssr, branch, page, manifest)
 		});
 	} catch (e) {
@@ -372,7 +361,6 @@ export async function render_page(event, state, page, options, manifest, nodes,
 		return await respond_with_error({
 			event,
 			state,
-			options,
 			manifest,
 			error: e,
 			resolve_opts
@@ -386,35 +374,10 @@ export async function render_page(event, state, page, options, manifest, nodes,
  * @param {PageNodeIndexes} page
  * @param {SSRManifest} manifest
  */
-async function load_error_components(ssr, branch, page, manifest) {
-	/** @type {Array<Component | undefined> | undefined} */
-	let error_components;
-
-	if (ssr) {
-		let last_idx = -1;
-		error_components = await Promise.all(
-			// eslint-disable-next-line @typescript-eslint/await-thenable
-			branch
-				.map((b, i) => {
-					if (i === 0) return undefined; // root layout wraps root error component, not the other way around
-					if (!b) return null;
-
-					i--;
-					// Find the closest error component up to the previous branch
-					while (i > last_idx + 1 && page.errors[i] === undefined) i -= 1;
-					last_idx = i;
-
-					const idx = page.errors[i];
-					if (idx == null) return undefined;
-
-					return manifest._.nodes[idx]?.()
-						.then((e) => e.component?.())
-						.catch(() => undefined);
-				})
-				// filter out indexes where there was no branch, but keep indexes where there was a branch but no error component
-				.filter((e) => e !== null)
-		);
-	}
+function load_error_components(ssr, branch, page, manifest) {
+	if (!ssr) return undefined;
 
-	return error_components;
+	return build_error_chain(branch, page.errors, (idx) =>
+		manifest._.nodes[idx]?.().then((e) => e.component?.())
+	);
 }

package/src/runtime/server/page/render.js

@@ -18,15 +18,16 @@ import {
 	route_id_resolution_pathname
 } from '../../pathname.js';
 import { try_get_request_store, with_request_store } from '@sveltejs/kit/internal/server';
-import { text_encoder } from '../../utils.js';
-import { count_non_ssi_comments, get_global_name } from '../utils.js';
+import { stream_text } from '../../utils.js';
+import { count_non_ssi_comments } from '../utils.js';
 import { handle_error_and_jsonify } from '../errors.js';
-import * as env from '__sveltekit/env';
+import * as env from '<sveltekit:generated>/env/config.js';
 import { collect_remote_data } from '../remote-functions.js';
 import Root from '../../components/root.svelte';
 import { render } from 'svelte/server';
 import { Props, RenderNode } from '../../props.svelte.js';
 import { has_custom_transporters, uneval } from '#app/internal/transport';
+import { options } from '../internal.js';
 
 // TODO rename this function/module
 
@@ -35,7 +36,6 @@ import { has_custom_transporters, uneval } from '#app/internal/transport';
  * @param {{
  *   branch: Array<import('./types.js').Loaded>;
  *   fetched: Array<import('./types.js').Fetched>;
- *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
  *   page_config: { ssr: boolean; csr: boolean };
  *   status: number;
@@ -43,7 +43,7 @@ import { has_custom_transporters, uneval } from '#app/internal/transport';
  *   event: import('@sveltejs/kit').RequestEvent;
  *   state: import('types').RequestState;
  *   resolve_opts: import('types').RequiredResolveOptions;
- *   action_result?: import('$app/forms').ActionResult;
+ *   action_result?: import('types').ServerActionResult;
  *   data_serializer: import('./types.js').ServerDataSerializer;
  *   error_components?: Array<import('svelte').Component | undefined>
  * }} opts
@@ -51,7 +51,6 @@ import { has_custom_transporters, uneval } from '#app/internal/transport';
 export async function render_response({
 	branch,
 	fetched,
-	options,
 	manifest,
 	page_config,
 	status,
@@ -77,7 +76,9 @@ export async function render_response({
 
 	const modulepreloads = new Set(client?.imports);
 	const stylesheets = new Set(client?.stylesheets);
-	const fonts = new Set(client?.fonts);
+
+	/** @type {Map<string, import('types').FontDependency>} */
+	const fonts = new Map(client?.fonts.map((font) => [font.file, font]));
 
 	/**
 	 * The value of the Link header that is added to the response when not prerendering
@@ -90,7 +91,7 @@ export async function render_response({
 	const inline_styles = new Map();
 
 	// TODO `svelte/server` should expose `RenderOutput`
-	/** @type {{ head: string, body: string, hashes: { script: string[] } }} */
+	/** @type {Omit<Awaited<ReturnType<typeof render>>, 'html'>} */
 	let rendered;
 
 	const form_value =
@@ -132,7 +133,7 @@ export async function render_response({
 			if (!paths.assets || (paths.assets[0] === '/' && paths.assets !== SVELTE_KIT_ASSETS)) {
 				assets = base;
 			}
-		} else if (options.hash_routing) {
+		} else if (__SVELTEKIT_HASH_ROUTING__) {
 			// we have to assume that we're in the right place
 			base_expression = "new URL('.', location).pathname.slice(0, -1)";
 		}
@@ -156,7 +157,7 @@ export async function render_response({
 			tree: new RenderNode(
 				// TODO tidy up
 				/** @type {Component} */ (await branch[0].node.component?.()),
-				/** @type {Component} */ (error_components?.[1])
+				undefined
 			),
 			form: form_value,
 			error: error ?? undefined
@@ -176,7 +177,7 @@ export async function render_response({
 				current_node = current_node.child = new RenderNode(
 					// TODO tidy up
 					/** @type {Component} */ (await branch[i + 1].node.component?.()),
-					/** @type {Component} */ (error_components?.slice(0, i + 2).findLast((x) => x))
+					error_components?.[i + 1]
 				);
 			}
 		}
@@ -201,7 +202,7 @@ export async function render_response({
 							throw e;
 						}
 
-						const handled = handle_error_and_jsonify(event, render_state, options, e);
+						const handled = handle_error_and_jsonify(event, render_state, e);
 
 						// TODO 4.0 make this an async function and await `handled`
 						if (handled instanceof Promise) {
@@ -244,19 +245,12 @@ export async function render_response({
 			}
 
 			rendered = await with_request_store({ event, state: render_state }, async () => {
-				// We have to invoke .then eagerly here in order to kick off rendering: it's only starting on access,
-				// and `await maybe_promise` would eagerly access the .then property but call its function only after a tick, which is too late
-				// for the paths.reset() below and for any eager getRequestEvent() calls during rendering without AsyncLocalStorage available.
-				const rendered = render(Root, { ...render_opts, props });
-
-				const { head, body, hashes } = await rendered;
-
-				if (hashes) {
-					csp.add_script_hashes(hashes.script);
-				}
-
-				return { head, body, hashes };
+				return render(Root, { ...render_opts, props });
 			});
+
+			if (rendered.hashes) {
+				csp.add_script_hashes(rendered.hashes.script);
+			}
 		} finally {
 			if (DEV) {
 				globalThis.fetch = fetch;
@@ -269,7 +263,7 @@ export async function render_response({
 	for (const { node } of branch) {
 		for (const url of node.imports) modulepreloads.add(url);
 		for (const url of node.stylesheets) stylesheets.add(url);
-		for (const url of node.fonts) fonts.add(url);
+		for (const font of node.fonts) fonts.set(font.file, font);
 
 		if (node.inline_styles && !client?.inline) {
 			Object.entries(await node.inline_styles()).forEach(([filename, css]) => {
@@ -317,7 +311,10 @@ export async function render_response({
 	 * @param {string[]} attributes
 	 */
 	const add_preload = (path, attributes) => {
-		if (options.link_header_preload && !(state.prerendering || state.prerender_default === true)) {
+		if (
+			__SVELTEKIT_LINK_HEADER_PRELOAD__ &&
+			!(state.prerendering || state.prerender_default === true)
+		) {
 			link_headers.add(`<${encodeURI(path)}>; ${attributes.join('; ')}; nopush`);
 		} else {
 			head.add_link_tag(path, attributes);
@@ -334,7 +331,7 @@ export async function render_response({
 			// include them in disabled state so that Vite can detect them and doesn't try to add them
 			attributes.push('disabled', 'media="(max-width: 0)"');
 		} else {
-			if (options.link_header_preload && resolve_opts.preload({ type: 'css', path })) {
+			if (__SVELTEKIT_LINK_HEADER_PRELOAD__ && resolve_opts.preload({ type: 'css', path })) {
 				link_headers.add(`<${encodeURI(path)}>; rel="preload"; as="style"; nopush`);
 			}
 		}
@@ -342,17 +339,17 @@ export async function render_response({
 		head.add_stylesheet(path, attributes);
 	}
 
-	for (const dep of fonts) {
-		const path = prefixed(dep);
+	for (const { file, filename } of fonts.values()) {
+		const path = prefixed(file);
 
-		if (resolve_opts.preload({ type: 'font', path })) {
-			const ext = dep.slice(dep.lastIndexOf('.') + 1);
+		if (resolve_opts.preload({ type: 'font', path, filename })) {
+			const ext = file.slice(file.lastIndexOf('.') + 1);
 
 			add_preload(path, ['rel="preload"', 'as="font"', `type="font/${ext}"`, 'crossorigin']);
 		}
 	}
 
-	const global = get_global_name(options);
+	const global = __SVELTEKIT_GLOBAL_NAME__;
 	const { data, chunks } = data_serializer.get_data(csp);
 
 	if (page_config.ssr && page_config.csr) {
@@ -514,7 +511,7 @@ export async function render_response({
 					); // make output after it's put together with the rest more readable
 					hydrate.push(`params: ${devalue.uneval(event.params)}`, `server_route: ${stringified}`);
 				}
-			} else if (options.embedded) {
+			} else if (__SVELTEKIT_EMBEDDED__) {
 				hydrate.push(`params: ${devalue.uneval(event.params)}`, `route: ${s(event.route)}`);
 			}
 
@@ -522,7 +519,7 @@ export async function render_response({
 			args.push(`{\n${indent}\t${hydrate.join(`,\n${indent}\t`)}\n${indent}}`);
 		}
 
-		const remote_data = await collect_remote_data({}, event, state, options);
+		const remote_data = await collect_remote_data({}, event, state);
 
 		const serialized_data =
 			Object.keys(remote_data).length > 0
@@ -554,7 +551,7 @@ export async function render_response({
 			blocks.push(boot);
 		}
 
-		if (options.service_worker) {
+		if (__SVELTEKIT_SERVICE_WORKER__) {
 			let opts = ", { type: 'module' }";
 			if (options.service_worker_options != null) {
 				const service_worker_options = { ...options.service_worker_options, type: 'module' };
@@ -615,7 +612,7 @@ export async function render_response({
 			headers.set('content-security-policy-report-only', report_only_header);
 		}
 
-		if (options.link_header_preload && link_headers.size) {
+		if (__SVELTEKIT_LINK_HEADER_PRELOAD__ && link_headers.size) {
 			headers.set('link', Array.from(link_headers).join(', '));
 		}
 	}
@@ -662,22 +659,7 @@ export async function render_response({
 				status,
 				headers
 			})
-		: new Response(
-				new ReadableStream({
-					async start(controller) {
-						controller.enqueue(text_encoder.encode(transformed + '\n'));
-						for await (const chunk of chunks) {
-							if (chunk.length) controller.enqueue(text_encoder.encode(chunk));
-						}
-						controller.close();
-					},
-
-					type: 'bytes'
-				}),
-				{
-					headers
-				}
-			);
+		: new Response(stream_text(transformed + '\n', chunks), { headers });
 }
 
 class Head {

package/src/runtime/server/page/respond_with_error.js

@@ -14,17 +14,16 @@ import { server_data_serializer } from './data_serializer.js';
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
  *   state: import('types').RequestState;
- *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
  *   error: unknown;
  *   resolve_opts: import('types').RequiredResolveOptions;
  * }} opts
  */
-export async function respond_with_error({ event, state, options, manifest, error, resolve_opts }) {
+export async function respond_with_error({ event, state, manifest, error, resolve_opts }) {
 	// reroute to the fallback page to prevent an infinite chain of requests.
 	if (event.request.headers.get('x-sveltekit-error')) {
-		const transformed = await handle_error_and_jsonify(event, state, options, error);
-		return static_error_page(options, transformed.status, transformed.message);
+		const transformed = await handle_error_and_jsonify(event, state, error);
+		return static_error_page(transformed.status, transformed.message);
 	}
 
 	/** @type {import('./types.js').Fetched[]} */
@@ -35,9 +34,9 @@ export async function respond_with_error({ event, state, options, manifest, erro
 		const nodes = new PageNodes([default_layout]);
 		const ssr = nodes.ssr();
 		const csr = nodes.csr();
-		const data_serializer = server_data_serializer(event, state, options);
+		const data_serializer = server_data_serializer(event, state);
 		// Do this here first in case the awaits below before rendering themselves error
-		const transformed = await handle_error_and_jsonify(event, state, options, error);
+		const transformed = await handle_error_and_jsonify(event, state, error);
 
 		if (ssr) {
 			state.error = true;
@@ -80,7 +79,6 @@ export async function respond_with_error({ event, state, options, manifest, erro
 		}
 
 		return await render_response({
-			options,
 			manifest,
 			page_config: {
 				ssr,
@@ -103,8 +101,8 @@ export async function respond_with_error({ event, state, options, manifest, erro
 			return redirect_response(e.status, e.location);
 		}
 
-		const transformed = await handle_error_and_jsonify(event, state, options, e);
+		const transformed = await handle_error_and_jsonify(event, state, e);
 
-		return static_error_page(options, transformed.status, transformed.message);
+		return static_error_page(transformed.status, transformed.message);
 	}
 }