@sveltejs/kit 2.17.3 → 2.19.0

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

@@ -13,9 +13,7 @@ import {
 import { load_data, load_server_data } from './load_data.js';
 import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
-import { get_option } from '../../../utils/options.js';
 import { get_data_json } from '../data/index.js';
-import { load_page_nodes } from './load_page_nodes.js';
 import { DEV } from 'esm-env';
 
 /**
@@ -29,10 +27,11 @@ const MAX_DEPTH = 10;
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {import('types').SSRState} state
+ * @param {import('../../../utils/page_nodes.js').PageNodes} nodes
  * @param {import('types').RequiredResolveOptions} resolve_opts
  * @returns {Promise<Response>}
  */
-export async function render_page(event, page, options, manifest, state, resolve_opts) {
+export async function render_page(event, page, options, manifest, state, nodes, resolve_opts) {
 	if (state.depth > MAX_DEPTH) {
 		// infinite request cycle detected
 		return text(`Not found: ${event.url.pathname}`, {
@@ -46,9 +45,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 	}
 
 	try {
-		const nodes = await load_page_nodes(page, manifest);
-
-		const leaf_node = /** @type {import('types').SSRNode} */ (nodes.at(-1));
+		const leaf_node = /** @type {import('types').SSRNode} */ (nodes.page());
 
 		let status = 200;
 
@@ -70,16 +67,10 @@ export async function render_page(event, page, options, manifest, state, resolve
 			}
 		}
 
-		const should_prerender_data = nodes.some(
-			// prerender in case of trailingSlash because the client retrieves that value from the server
-			(node) => node?.server?.load || node?.server?.trailingSlash !== undefined
-		);
-		const data_pathname = add_data_suffix(event.url.pathname);
-
 		// it's crucial that we do this before returning the non-SSR response, otherwise
 		// SvelteKit will erroneously believe that the path has been prerendered,
 		// causing functions to be omitted from the manifest generated later
-		const should_prerender = get_option(nodes, 'prerender') ?? false;
+		const should_prerender = nodes.prerender();
 		if (should_prerender) {
 			const mod = leaf_node.server;
 			if (mod?.actions) {
@@ -96,13 +87,16 @@ export async function render_page(event, page, options, manifest, state, resolve
 		// inherit the prerender option of the page
 		state.prerender_default = should_prerender;
 
+		const should_prerender_data = nodes.should_prerender_data();
+		const data_pathname = add_data_suffix(event.url.pathname);
+
 		/** @type {import('./types.js').Fetched[]} */
 		const fetched = [];
 
 		// renders an empty 'shell' page if SSR is turned off and if there is
 		// no server data to prerender. As a result, the load functions and rendering
 		// only occur client-side.
-		if (get_option(nodes, 'ssr') === false && !(state.prerendering && should_prerender_data)) {
+		if (nodes.ssr() === false && !(state.prerendering && should_prerender_data)) {
 			// if the user makes a request through a non-enhanced form, the returned value is lost
 			// because there is no SSR or client-side handling of the response
 			if (DEV && action_result && !event.request.headers.has('x-sveltekit-action')) {
@@ -123,7 +117,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 				fetched,
 				page_config: {
 					ssr: false,
-					csr: get_option(nodes, 'csr') ?? true
+					csr: nodes.csr()
 				},
 				status,
 				error: null,
@@ -142,7 +136,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 		let load_error = null;
 
 		/** @type {Array<Promise<import('types').ServerDataNode | null>>} */
-		const server_promises = nodes.map((node, i) => {
+		const server_promises = nodes.data.map((node, i) => {
 			if (load_error) {
 				// if an error happens immediately, don't bother with the rest of the nodes
 				throw load_error;
@@ -177,10 +171,10 @@ export async function render_page(event, page, options, manifest, state, resolve
 			});
 		});
 
-		const csr = get_option(nodes, 'csr') ?? true;
+		const csr = nodes.csr();
 
 		/** @type {Array<Promise<Record<string, any> | null>>} */
-		const load_promises = nodes.map((node, i) => {
+		const load_promises = nodes.data.map((node, i) => {
 			if (load_error) throw load_error;
 			return Promise.resolve().then(async () => {
 				try {
@@ -211,8 +205,8 @@ export async function render_page(event, page, options, manifest, state, resolve
 		for (const p of server_promises) p.catch(() => {});
 		for (const p of load_promises) p.catch(() => {});
 
-		for (let i = 0; i < nodes.length; i += 1) {
-			const node = nodes[i];
+		for (let i = 0; i < nodes.data.length; i += 1) {
+			const node = nodes.data[i];
 
 			if (node) {
 				try {
@@ -300,7 +294,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 			});
 		}
 
-		const ssr = get_option(nodes, 'ssr') ?? true;
+		const ssr = nodes.ssr();
 
 		return await render_response({
 			event,
@@ -309,7 +303,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 			state,
 			resolve_opts,
 			page_config: {
-				csr: get_option(nodes, 'csr') ?? true,
+				csr: nodes.csr(),
 				ssr
 			},
 			status,

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

@@ -78,7 +78,7 @@ export async function load_server_data({ event, state, node, parent }) {
 				const { href } = new URL(dep, event.url);
 
 				if (DEV) {
-					validate_depends(node.server_id, dep);
+					validate_depends(node.server_id || 'missing route ID', dep);
 
 					if (done && !uses.dependencies.has(href)) {
 						console.warn(

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

@@ -116,11 +116,6 @@ export async function render_response({
 	}
 
 	if (page_config.ssr) {
-		if (__SVELTEKIT_DEV__ && !branch.at(-1)?.node.component) {
-			// Can only be the leaf, layouts have a fallback component generated
-			throw new Error(`Missing +page.svelte component for route ${event.route.id}`);
-		}
-
 		/** @type {Record<string, any>} */
 		const props = {
 			stores: {
@@ -128,7 +123,15 @@ export async function render_response({
 				navigating: writable(null),
 				updated
 			},
-			constructors: await Promise.all(branch.map(({ node }) => node.component())),
+			constructors: await Promise.all(
+				branch.map(({ node }) => {
+					if (!node.component) {
+						// Can only be the leaf, layouts have a fallback component generated
+						throw new Error(`Missing +page.svelte component for route ${event.route.id}`);
+					}
+					return node.component();
+				})
+			),
 			form: form_value
 		};
 

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

@@ -1,9 +1,9 @@
 import { render_response } from './render.js';
 import { load_data, load_server_data } from './load_data.js';
 import { handle_error_and_jsonify, static_error_page, redirect_response } from '../utils.js';
-import { get_option } from '../../../utils/options.js';
 import { Redirect } from '../../control.js';
 import { get_status } from '../../../utils/error.js';
+import { PageNodes } from '../../../utils/page_nodes.js';
 
 /**
  * @typedef {import('./types.js').Loaded} Loaded
@@ -40,8 +40,9 @@ export async function respond_with_error({
 	try {
 		const branch = [];
 		const default_layout = await manifest._.nodes[0](); // 0 is always the root layout
-		const ssr = get_option([default_layout], 'ssr') ?? true;
-		const csr = get_option([default_layout], 'csr') ?? true;
+		const nodes = new PageNodes([default_layout]);
+		const ssr = nodes.ssr();
+		const csr = nodes.csr();
 
 		if (ssr) {
 			state.error = true;

package/src/runtime/server/respond.js

@@ -11,21 +11,13 @@ import { exec } from '../../utils/routing.js';
 import { redirect_json_response, render_data } from './data/index.js';
 import { add_cookies_to_headers, get_cookies } from './cookie.js';
 import { create_fetch } from './fetch.js';
+import { PageNodes } from '../../utils/page_nodes.js';
 import { HttpError, Redirect, SvelteKitError } from '../control.js';
-import {
-	validate_layout_exports,
-	validate_layout_server_exports,
-	validate_page_exports,
-	validate_page_server_exports,
-	validate_server_exports
-} from '../../utils/exports.js';
-import { get_option } from '../../utils/options.js';
+import { validate_server_exports } from '../../utils/exports.js';
 import { json, text } from '../../exports/index.js';
 import { action_json_redirect, is_action_json_request } from './page/actions.js';
 import { INVALIDATED_PARAM, TRAILING_SLASH_PARAM } from '../shared.js';
 import { get_public_env } from './env_module.js';
-import { load_page_nodes } from './page/load_page_nodes.js';
-import { get_page_config } from '../../utils/route_config.js';
 import { resolve_route } from './page/server_routing.js';
 import { validateHeaders } from './validate-headers.js';
 import {
@@ -111,11 +103,82 @@ export async function respond(request, options, manifest, state) {
 		url.searchParams.delete(INVALIDATED_PARAM);
 	}
 
+	/** @type {Record<string, string>} */
+	const headers = {};
+
+	const { cookies, new_cookies, get_cookie_header, set_internal, set_trailing_slash } = get_cookies(
+		request,
+		url
+	);
+
+	/** @type {import('@sveltejs/kit').RequestEvent} */
+	const event = {
+		cookies,
+		// @ts-expect-error `fetch` needs to be created after the `event` itself
+		fetch: null,
+		getClientAddress:
+			state.getClientAddress ||
+			(() => {
+				throw new Error(
+					`${__SVELTEKIT_ADAPTER_NAME__} does not specify getClientAddress. Please raise an issue`
+				);
+			}),
+		locals: {},
+		params: {},
+		platform: state.platform,
+		request,
+		route: { id: null },
+		setHeaders: (new_headers) => {
+			if (__SVELTEKIT_DEV__) {
+				validateHeaders(new_headers);
+			}
+
+			for (const key in new_headers) {
+				const lower = key.toLowerCase();
+				const value = new_headers[key];
+
+				if (lower === 'set-cookie') {
+					throw new Error(
+						'Use `event.cookies.set(name, value, options)` instead of `event.setHeaders` to set cookies'
+					);
+				} else if (lower in headers) {
+					throw new Error(`"${key}" header is already set`);
+				} else {
+					headers[lower] = value;
+
+					if (state.prerendering && lower === 'cache-control') {
+						state.prerendering.cache = /** @type {string} */ (value);
+					}
+				}
+			}
+		},
+		url,
+		isDataRequest: is_data_request,
+		isSubRequest: state.depth > 0
+	};
+
+	event.fetch = create_fetch({
+		event,
+		options,
+		manifest,
+		state,
+		get_cookie_header,
+		set_internal
+	});
+
+	if (state.emulator?.platform) {
+		event.platform = await state.emulator.platform({
+			config: {},
+			prerender: !!state.prerendering?.fallback
+		});
+	}
+
 	let resolved_path;
 
 	try {
 		// reroute could alter the given URL, so we pass a copy
-		resolved_path = options.hooks.reroute({ url: new URL(url) }) ?? url.pathname;
+		resolved_path =
+			(await options.hooks.reroute({ url: new URL(url), fetch: event.fetch })) ?? url.pathname;
 	} catch {
 		return text('Internal Server Error', {
 			status: 500
@@ -131,9 +194,6 @@ export async function respond(request, options, manifest, state) {
 	/** @type {import('types').SSRRoute | null} */
 	let route = null;
 
-	/** @type {Record<string, string>} */
-	let params = {};
-
 	if (base && !state.prerendering?.fallback) {
 		if (!resolved_path.startsWith(base)) {
 			return text('Not found', { status: 404 });
@@ -167,68 +227,13 @@ export async function respond(request, options, manifest, state) {
 			const matched = exec(match, candidate.params, matchers);
 			if (matched) {
 				route = candidate;
-				params = decode_params(matched);
+				event.route = { id: route.id };
+				event.params = decode_params(matched);
 				break;
 			}
 		}
 	}
 
-	/** @type {import('types').TrailingSlash | void} */
-	let trailing_slash = undefined;
-
-	/** @type {Record<string, string>} */
-	const headers = {};
-
-	/** @type {Record<string, import('./page/types.js').Cookie>} */
-	let cookies_to_add = {};
-
-	/** @type {import('@sveltejs/kit').RequestEvent} */
-	const event = {
-		// @ts-expect-error `cookies` and `fetch` need to be created after the `event` itself
-		cookies: null,
-		// @ts-expect-error
-		fetch: null,
-		getClientAddress:
-			state.getClientAddress ||
-			(() => {
-				throw new Error(
-					`${__SVELTEKIT_ADAPTER_NAME__} does not specify getClientAddress. Please raise an issue`
-				);
-			}),
-		locals: {},
-		params,
-		platform: state.platform,
-		request,
-		route: { id: route?.id ?? null },
-		setHeaders: (new_headers) => {
-			if (__SVELTEKIT_DEV__) {
-				validateHeaders(new_headers);
-			}
-
-			for (const key in new_headers) {
-				const lower = key.toLowerCase();
-				const value = new_headers[key];
-
-				if (lower === 'set-cookie') {
-					throw new Error(
-						'Use `event.cookies.set(name, value, options)` instead of `event.setHeaders` to set cookies'
-					);
-				} else if (lower in headers) {
-					throw new Error(`"${key}" header is already set`);
-				} else {
-					headers[lower] = value;
-
-					if (state.prerendering && lower === 'cache-control') {
-						state.prerendering.cache = /** @type {string} */ (value);
-					}
-				}
-			}
-		},
-		url,
-		isDataRequest: is_data_request,
-		isSubRequest: state.depth > 0
-	};
-
 	/** @type {import('types').RequiredResolveOptions} */
 	let resolve_opts = {
 		transformPageChunk: default_transform,
@@ -236,51 +241,36 @@ export async function respond(request, options, manifest, state) {
 		preload: default_preload
 	};
 
+	/** @type {import('types').TrailingSlash} */
+	let trailing_slash = 'never';
+
 	try {
+		/** @type {PageNodes|undefined} */
+		const page_nodes = route?.page
+			? new PageNodes(await load_page_nodes(route.page, manifest))
+			: undefined;
+
 		// determine whether we need to redirect to add/remove a trailing slash
 		if (route) {
 			// if `paths.base === '/a/b/c`, then the root route is `/a/b/c/`,
 			// regardless of the `trailingSlash` route option
 			if (url.pathname === base || url.pathname === base + '/') {
 				trailing_slash = 'always';
-			} else if (route.page) {
-				const nodes = await load_page_nodes(route.page, manifest);
-
+			} else if (page_nodes) {
 				if (DEV) {
-					const layouts = nodes.slice(0, -1);
-					const page = nodes.at(-1);
-
-					for (const layout of layouts) {
-						if (layout) {
-							validate_layout_server_exports(
-								layout.server,
-								/** @type {string} */ (layout.server_id)
-							);
-							validate_layout_exports(
-								layout.universal,
-								/** @type {string} */ (layout.universal_id)
-							);
-						}
-					}
-
-					if (page) {
-						validate_page_server_exports(page.server, /** @type {string} */ (page.server_id));
-						validate_page_exports(page.universal, /** @type {string} */ (page.universal_id));
-					}
+					page_nodes.validate();
 				}
-
-				trailing_slash = get_option(nodes, 'trailingSlash');
+				trailing_slash = page_nodes.trailing_slash();
 			} else if (route.endpoint) {
 				const node = await route.endpoint();
-				trailing_slash = node.trailingSlash;
-
+				trailing_slash = node.trailingSlash ?? 'never';
 				if (DEV) {
 					validate_server_exports(node, /** @type {string} */ (route.endpoint_id));
 				}
 			}
 
 			if (!is_data_request) {
-				const normalized = normalize_path(url.pathname, trailing_slash ?? 'never');
+				const normalized = normalize_path(url.pathname, trailing_slash);
 
 				if (normalized !== url.pathname && !state.prerendering?.fallback) {
 					return new Response(undefined, {
@@ -306,10 +296,9 @@ export async function respond(request, options, manifest, state) {
 					const node = await route.endpoint();
 					config = node.config ?? config;
 					prerender = node.prerender ?? prerender;
-				} else if (route.page) {
-					const nodes = await load_page_nodes(route.page, manifest);
-					config = get_page_config(nodes) ?? config;
-					prerender = get_option(nodes, 'prerender') ?? false;
+				} else if (page_nodes) {
+					config = page_nodes.get_config() ?? config;
+					prerender = page_nodes.prerender();
 				}
 
 				if (state.before_handle) {
@@ -320,36 +309,16 @@ export async function respond(request, options, manifest, state) {
 					event.platform = await state.emulator.platform({ config, prerender });
 				}
 			}
-		} else if (state.emulator?.platform) {
-			event.platform = await state.emulator.platform({
-				config: {},
-				prerender: !!state.prerendering?.fallback
-			});
 		}
 
-		const { cookies, new_cookies, get_cookie_header, set_internal } = get_cookies(
-			request,
-			url,
-			trailing_slash ?? 'never'
-		);
-
-		cookies_to_add = new_cookies;
-		event.cookies = cookies;
-		event.fetch = create_fetch({
-			event,
-			options,
-			manifest,
-			state,
-			get_cookie_header,
-			set_internal
-		});
+		set_trailing_slash(trailing_slash);
 
 		if (state.prerendering && !state.prerendering.fallback) disable_search(url);
 
 		const response = await options.hooks.handle({
 			event,
 			resolve: (event, opts) =>
-				resolve(event, opts).then((response) => {
+				resolve(event, page_nodes, opts).then((response) => {
 					// add headers/cookies here, rather than inside `resolve`, so that we
 					// can do it once for all responses instead of once per `return`
 					for (const key in headers) {
@@ -357,7 +326,7 @@ export async function respond(request, options, manifest, state) {
 						response.headers.set(key, /** @type {string} */ (value));
 					}
 
-					add_cookies_to_headers(response.headers, Object.values(cookies_to_add));
+					add_cookies_to_headers(response.headers, Object.values(new_cookies));
 
 					if (state.prerendering && event.route.id !== null) {
 						response.headers.set('x-sveltekit-routeid', encodeURI(event.route.id));
@@ -418,7 +387,7 @@ export async function respond(request, options, manifest, state) {
 				: route?.page && is_action_json_request(event)
 					? action_json_redirect(e)
 					: redirect_response(e.status, e.location);
-			add_cookies_to_headers(response.headers, Object.values(cookies_to_add));
+			add_cookies_to_headers(response.headers, Object.values(new_cookies));
 			return response;
 		}
 		return await handle_fatal_error(event, options, e);
@@ -426,9 +395,10 @@ export async function respond(request, options, manifest, state) {
 
 	/**
 	 * @param {import('@sveltejs/kit').RequestEvent} event
+	 * @param {PageNodes | undefined} page_nodes
 	 * @param {import('@sveltejs/kit').ResolveOptions} [opts]
 	 */
-	async function resolve(event, opts) {
+	async function resolve(event, page_nodes, opts) {
 		try {
 			if (opts) {
 				resolve_opts = {
@@ -467,13 +437,23 @@ export async function respond(request, options, manifest, state) {
 						manifest,
 						state,
 						invalidated_data_nodes,
-						trailing_slash ?? 'never'
+						trailing_slash
 					);
 				} else if (route.endpoint && (!route.page || is_endpoint_request(event))) {
 					response = await render_endpoint(event, await route.endpoint(), state);
 				} else if (route.page) {
-					if (page_methods.has(method)) {
-						response = await render_page(event, route.page, options, manifest, state, resolve_opts);
+					if (!page_nodes) {
+						throw new Error('page_nodes not found. This should never happen');
+					} else if (page_methods.has(method)) {
+						response = await render_page(
+							event,
+							route.page,
+							options,
+							manifest,
+							state,
+							page_nodes,
+							resolve_opts
+						);
 					} else {
 						const allowed_methods = new Set(allowed_page_methods);
 						const node = await manifest._.nodes[route.page.leaf]();
@@ -499,9 +479,8 @@ export async function respond(request, options, manifest, state) {
 						}
 					}
 				} else {
-					// a route will always have a page or an endpoint, but TypeScript
-					// doesn't know that
-					throw new Error('This should never happen');
+					// a route will always have a page or an endpoint, but TypeScript doesn't know that
+					throw new Error('Route is neither page nor endpoint. This should never happen');
 				}
 
 				// If the route contains a page and an endpoint, we need to add a
@@ -578,3 +557,15 @@ export async function respond(request, options, manifest, state) {
 		}
 	}
 }
+
+/**
+ * @param {import('types').PageNodeIndexes} page
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ */
+export function load_page_nodes(page, manifest) {
+	return Promise.all([
+		// we use == here rather than === because [undefined] serializes as "[null]"
+		...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
+		manifest._.nodes[page.leaf]()
+	]);
+}