@sveltejs/kit 2.50.2 → 2.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.50.2",
+  "version": "2.52.0",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -34,7 +34,7 @@
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.0.0",
-    "@playwright/test": "1.56.0",
+    "@playwright/test": "1.58.2",
     "@sveltejs/vite-plugin-svelte": "^6.0.0-next.3",
     "@types/connect": "^3.4.38",
     "@types/node": "^18.19.119",

package/src/core/postbuild/analyse.js

@@ -65,21 +65,8 @@ async function analyse({
 	internal.set_manifest(manifest);
 	internal.set_read_implementation((file) => createReadableStream(`${server_root}/server/${file}`));
 
-	/** @type {Map<string, { page_options: Record<string, any> | null, children: string[] }>} */
-	const static_exports = new Map();
-
 	// first, build server nodes without the client manifest so we can analyse it
-	await build_server_nodes(
-		out,
-		config,
-		manifest_data,
-		server_manifest,
-		null,
-		null,
-		null,
-		output_config,
-		static_exports
-	);
+	build_server_nodes(out, config, manifest_data, server_manifest, null, null, null, output_config);
 
 	/** @type {import('types').ServerMetadata} */
 	const metadata = {
@@ -188,7 +175,7 @@ async function analyse({
 		metadata.remotes.set(remote.hash, exports);
 	}
 
-	return { metadata, static_exports };
+	return { metadata };
 }
 
 /**

package/src/core/sync/create_manifest_data/index.js

@@ -8,6 +8,10 @@ import { posixify, resolve_entry } from '../../../utils/filesystem.js';
 import { parse_route_id } from '../../../utils/routing.js';
 import { sort_routes } from './sort.js';
 import { isSvelte5Plus } from '../utils.js';
+import {
+	create_node_analyser,
+	get_page_options
+} from '../../../exports/vite/static_analysis/index.js';
 
 /**
  * Generates the manifest data used for the client-side manifest and types generation.
@@ -342,7 +346,8 @@ function create_routes_and_nodes(cwd, config, fallback) {
 					}
 
 					route.endpoint = {
-						file: project_relative
+						file: project_relative,
+						page_options: null // will be filled later
 					};
 				}
 			}
@@ -415,6 +420,8 @@ function create_routes_and_nodes(cwd, config, fallback) {
 
 	const indexes = new Map(nodes.map((node, i) => [node, i]));
 
+	const node_analyser = create_node_analyser();
+
 	for (const route of routes) {
 		if (!route.leaf) continue;
 
@@ -459,6 +466,16 @@ function create_routes_and_nodes(cwd, config, fallback) {
 		}
 	}
 
+	for (const node of nodes) {
+		node.page_options = node_analyser.get_page_options(node);
+	}
+
+	for (const route of routes) {
+		if (route.endpoint) {
+			route.endpoint.page_options = get_page_options(route.endpoint.file);
+		}
+	}
+
 	return {
 		nodes,
 		routes: sort_routes(routes)

package/src/core/sync/sync.js

@@ -7,6 +7,10 @@ import { write_types, write_all_types } from './write_types/index.js';
 import { write_ambient } from './write_ambient.js';
 import { write_non_ambient } from './write_non_ambient.js';
 import { write_server } from './write_server.js';
+import {
+	create_node_analyser,
+	get_page_options
+} from '../../exports/vite/static_analysis/index.js';
 
 /**
  * Initialize SvelteKit's generated files that only depend on the config and mode.
@@ -45,7 +49,20 @@ export function create(config) {
  * @param {string} file
  */
 export function update(config, manifest_data, file) {
+	const node_analyser = create_node_analyser();
+
+	for (const node of manifest_data.nodes) {
+		node.page_options = node_analyser.get_page_options(node);
+	}
+
+	for (const route of manifest_data.routes) {
+		if (route.endpoint) {
+			route.endpoint.page_options = get_page_options(route.endpoint.file);
+		}
+	}
+
 	write_types(config, manifest_data, file);
+	write_non_ambient(config.kit, manifest_data);
 }
 
 /**

package/src/core/sync/write_non_ambient.js

@@ -13,6 +13,40 @@ const remove_group_segments = (/** @type {string} */ id) => {
 	return '/' + get_route_segments(id).join('/');
 };
 
+/**
+ * Get pathnames to add based on trailingSlash settings
+ * @param {string} pathname
+ * @param {import('types').RouteData} route
+ * @returns {string[]}
+ */
+function get_pathnames_for_trailing_slash(pathname, route) {
+	if (pathname === '/') {
+		return [pathname];
+	}
+
+	/** @type {({ trailingSlash?: import('types').TrailingSlash } | null)[]} */
+	const routes = [];
+
+	if (route.leaf) routes.push(route.leaf.page_options ?? null);
+	if (route.endpoint) routes.push(route.endpoint.page_options);
+
+	/** @type {Set<string>} */
+	const pathnames = new Set();
+
+	for (const page_options of routes) {
+		if (page_options === null || page_options.trailingSlash === 'ignore') {
+			pathnames.add(pathname);
+			pathnames.add(pathname + '/');
+		} else if (page_options.trailingSlash === 'always') {
+			pathnames.add(pathname + '/');
+		} else {
+			pathnames.add(pathname);
+		}
+	}
+
+	return Array.from(pathnames);
+}
+
 // `declare module "svelte/elements"` needs to happen in a non-ambient module, and dts-buddy generates one big ambient module,
 // so we can't add it there - therefore generate the typings ourselves here.
 // We're not using the `declare namespace svelteHTML` variant because that one doesn't augment the HTMLAttributes interface
@@ -67,19 +101,14 @@ function generate_app_types(manifest_data) {
 
 			const pathname = remove_group_segments(route.id);
 			const replaced_pathname = replace_required_params(replace_optional_params(pathname));
-			pathnames.add(`\`${replaced_pathname}\` & {}`);
 
-			if (pathname !== '/') {
-				// Support trailing slash
-				pathnames.add(`\`${replaced_pathname + '/'}\` & {}`);
+			for (const p of get_pathnames_for_trailing_slash(replaced_pathname, route)) {
+				pathnames.add(`\`${p}\` & {}`);
 			}
 		} else {
 			const pathname = remove_group_segments(route.id);
-			pathnames.add(s(pathname));
-
-			if (pathname !== '/') {
-				// Support trailing slash
-				pathnames.add(s(pathname + '/'));
+			for (const p of get_pathnames_for_trailing_slash(pathname, route)) {
+				pathnames.add(s(p));
 			}
 		}
 

package/src/core/sync/write_tsconfig.js

@@ -62,10 +62,8 @@ export function get_tsconfig(kit) {
 		config_relative('vite.config.js'),
 		config_relative('vite.config.ts')
 	]);
-	// TODO(v2): find a better way to include all src files. We can't just use routes/lib only because
-	// people might have other folders/files in src that they want included.
-	const src_includes = [kit.files.routes, kit.files.lib, path.resolve('src')].filter((dir) => {
-		const relative = path.relative(path.resolve('src'), dir);
+	const src_includes = [kit.files.routes, kit.files.lib, kit.files.src].filter((dir) => {
+		const relative = path.relative(kit.files.src, dir);
 		return !relative || relative.startsWith('..');
 	});
 	for (const dir of src_includes) {
@@ -76,10 +74,14 @@ export function get_tsconfig(kit) {
 
 	// Test folder is a special case - we advocate putting tests in a top-level test folder
 	// and it's not configurable (should we make it?)
-	const test_folder = project_relative('tests');
+	const test_folder = project_relative('test');
 	include.add(config_relative(`${test_folder}/**/*.js`));
 	include.add(config_relative(`${test_folder}/**/*.ts`));
 	include.add(config_relative(`${test_folder}/**/*.svelte`));
+	const tests_folder = project_relative('tests');
+	include.add(config_relative(`${tests_folder}/**/*.js`));
+	include.add(config_relative(`${tests_folder}/**/*.ts`));
+	include.add(config_relative(`${tests_folder}/**/*.svelte`));
 
 	const exclude = [config_relative('node_modules/**')];
 	// Add service worker to exclude list so that worker types references in it don't spill over into the rest of the app

package/src/exports/public.d.ts

@@ -1200,6 +1200,19 @@ export interface NavigationTarget<
 	 * The URL that is navigated to
 	 */
 	url: URL;
+	/**
+	 * The scroll position associated with this navigation.
+	 *
+	 * For the `from` target, this is the scroll position at the moment of navigation.
+	 *
+	 * For the `to` target, this represents the scroll position that will be or was restored:
+	 * - In `beforeNavigate` and `onNavigate`, this is only available for `popstate` navigations (back/forward button)
+	 *   and will be `null` for other navigation types, since the final scroll position isn't known
+	 *   ahead of time.
+	 * - In `afterNavigate`, this is always the scroll position that was applied after the navigation
+	 *   completed.
+	 */
+	scroll: { x: number; y: number } | null;
 }
 
 /**
@@ -1249,7 +1262,7 @@ export interface NavigationEnter extends NavigationBase {
 	delta?: undefined;
 
 	/**
-	 * Dispatched `Event` object when navigation occured by `popstate` or `link`.
+	 * Dispatched `Event` object when navigation occurred by `popstate` or `link`.
 	 */
 	event?: undefined;
 }

package/src/exports/vite/build/build_server.js

@@ -3,38 +3,9 @@ import { mkdirp } from '../../../utils/filesystem.js';
 import { filter_fonts, find_deps, resolve_symlinks } from './utils.js';
 import { s } from '../../../utils/misc.js';
 import { normalizePath } from 'vite';
-import { basename, join } from 'node:path';
-import { create_node_analyser } from '../static_analysis/index.js';
+import { basename } from 'node:path';
 import { fix_css_urls } from '../../../utils/css.js';
 
-/**
- * Regenerate server nodes after acquiring client manifest
- * @overload
- * @param {string} out
- * @param {import('types').ValidatedKitConfig} kit
- * @param {import('types').ManifestData} manifest_data
- * @param {import('vite').Manifest} server_manifest
- * @param {import('vite').Manifest} client_manifest
- * @param {string} assets_path
- * @param {import('vite').Rollup.RollupOutput['output']} client_chunks
- * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
- * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
- * @returns {Promise<void>}
- */
-/**
- * Build server nodes without client manifest for analysis phase
- * @overload
- * @param {string} out
- * @param {import('types').ValidatedKitConfig} kit
- * @param {import('types').ManifestData} manifest_data
- * @param {import('vite').Manifest} server_manifest
- * @param {null} client_manifest
- * @param {null} assets_path
- * @param {null} client_chunks
- * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
- * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
- * @returns {Promise<void>}
- */
 /**
  * @param {string} out
  * @param {import('types').ValidatedKitConfig} kit
@@ -44,9 +15,8 @@ import { fix_css_urls } from '../../../utils/css.js';
  * @param {string | null} assets_path
  * @param {import('vite').Rollup.RollupOutput['output'] | null} client_chunks
  * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
- * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
  */
-export async function build_server_nodes(
+export function build_server_nodes(
 	out,
 	kit,
 	manifest_data,
@@ -54,8 +24,7 @@ export async function build_server_nodes(
 	client_manifest,
 	assets_path,
 	client_chunks,
-	output_config,
-	static_exports
+	output_config
 ) {
 	mkdirp(`${out}/server/nodes`);
 	mkdirp(`${out}/server/stylesheets`);
@@ -116,16 +85,6 @@ export async function build_server_nodes(
 		}
 	}
 
-	const { get_page_options } = create_node_analyser({
-		resolve: (server_node) => {
-			// Windows needs the file:// protocol for absolute path dynamic imports
-			return import(
-				`file://${join(out, 'server', resolve_symlinks(server_manifest, server_node).chunk.file)}`
-			);
-		},
-		static_exports
-	});
-
 	for (let i = 0; i < manifest_data.nodes.length; i++) {
 		const node = manifest_data.nodes[i];
 
@@ -159,9 +118,8 @@ export async function build_server_nodes(
 		}
 
 		if (node.universal) {
-			const page_options = await get_page_options(node);
-			if (!!page_options && page_options.ssr === false) {
-				exports.push(`export const universal = ${s(page_options, null, 2)};`);
+			if (!!node.page_options && node.page_options.ssr === false) {
+				exports.push(`export const universal = ${s(node.page_options, null, 2)};`);
 			} else {
 				imports.push(
 					`import * as universal from '../${resolve_symlinks(server_manifest, node.universal).chunk.file}';`

package/src/exports/vite/dev/index.js

@@ -19,7 +19,6 @@ import { not_found } from '../utils.js';
 import { SCHEME } from '../../../utils/url.js';
 import { check_feature } from '../../../utils/features.js';
 import { escape_html } from '../../../utils/escape.js';
-import { create_node_analyser } from '../static_analysis/index.js';
 
 const cwd = process.cwd();
 // vite-specifc queries that we should skip handling for css urls
@@ -103,9 +102,6 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 		return { module, module_node, url };
 	}
 
-	/** @type {(file: string) => void} */
-	let invalidate_page_options;
-
 	function update_manifest() {
 		try {
 			({ manifest_data } = sync.create(svelte_config));
@@ -129,14 +125,6 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 			return;
 		}
 
-		const node_analyser = create_node_analyser({
-			resolve: async (server_node) => {
-				const { module } = await resolve(server_node);
-				return module;
-			}
-		});
-		invalidate_page_options = node_analyser.invalidate_page_options;
-
 		manifest = {
 			appDir: svelte_config.kit.appDir,
 			appPath: svelte_config.kit.appDir,
@@ -215,9 +203,8 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 						}
 
 						if (node.universal) {
-							const page_options = await node_analyser.get_page_options(node);
-							if (page_options?.ssr === false) {
-								result.universal = page_options;
+							if (node.page_options?.ssr === false) {
+								result.universal = node.page_options;
 							} else {
 								// TODO: explain why the file was loaded on the server if we fail to load it
 								const { module, module_node } = await resolve(node.universal);
@@ -370,12 +357,8 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 	watch('unlink', () => debounce(update_manifest));
 	watch('change', (file) => {
 		// Don't run for a single file if the whole manifest is about to get updated
-		if (timeout || restarting) return;
-
-		if (/\+(page|layout).*$/.test(file)) {
-			invalidate_page_options(path.relative(cwd, file));
-		}
-
+		// Unless it's a file where the trailing slash page option might have changed
+		if (timeout || restarting || !/\+(page|layout|server).*$/.test(file)) return;
 		sync.update(svelte_config, manifest_data, file);
 	});
 

package/src/exports/vite/index.js

@@ -40,7 +40,7 @@ import {
 } from './module_ids.js';
 import { import_peer } from '../../utils/import.js';
 import { compact } from '../../utils/array.js';
-import { should_ignore } from './static_analysis/utils.js';
+import { should_ignore, has_children } from './static_analysis/utils.js';
 
 const cwd = posixify(process.cwd());
 
@@ -112,10 +112,8 @@ const warning_preprocessor = {
 		if (!filename) return;
 
 		const basename = path.basename(filename);
-		const has_children =
-			content.includes('<slot') || (isSvelte5Plus() && content.includes('{@render'));
 
-		if (basename.startsWith('+layout.') && !has_children) {
+		if (basename.startsWith('+layout.') && !has_children(content, isSvelte5Plus())) {
 			const message =
 				`\n${colors.bold().red(path.relative('.', filename))}\n` +
 				`\`<slot />\`${isSvelte5Plus() ? ' or `{@render ...}` tag' : ''}` +
@@ -1065,7 +1063,7 @@ async function kit({ svelte_config }) {
 
 				log.info('Analysing routes');
 
-				const { metadata, static_exports } = await analyse({
+				const { metadata } = await analyse({
 					hash: kit.router.type === 'hash',
 					manifest_path,
 					manifest_data,
@@ -1265,7 +1263,7 @@ async function kit({ svelte_config }) {
 				);
 
 				// regenerate nodes with the client manifest...
-				await build_server_nodes(
+				build_server_nodes(
 					out,
 					kit,
 					manifest_data,
@@ -1273,8 +1271,7 @@ async function kit({ svelte_config }) {
 					client_manifest,
 					assets_path,
 					client_chunks,
-					svelte_config.kit.output,
-					static_exports
+					svelte_config.kit.output
 				);
 
 				// ...and prerender

package/src/exports/vite/static_analysis/index.js

@@ -2,9 +2,21 @@ import { tsPlugin } from '@sveltejs/acorn-typescript';
 import { Parser } from 'acorn';
 import { read } from '../../../utils/filesystem.js';
 
-const inheritable_page_options = new Set(['ssr', 'prerender', 'csr', 'trailingSlash', 'config']);
-
-const valid_page_options = new Set([...inheritable_page_options, 'entries', 'load']);
+const valid_page_options_array = /** @type {const} */ ([
+	'ssr',
+	'prerender',
+	'csr',
+	'trailingSlash',
+	'config',
+	'entries',
+	'load'
+]);
+
+/** @type {Set<string>} */
+const valid_page_options = new Set(valid_page_options_array);
+
+/** @typedef {typeof valid_page_options_array[number]} ValidPageOption */
+/** @typedef {Partial<Record<ValidPageOption, any>>} PageOptions */
 
 const skip_parsing_regex = new RegExp(
 	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
@@ -18,11 +30,11 @@ const parser = Parser.extend(tsPlugin());
  * Returns `null` if any export is too difficult to analyse.
  * @param {string} filename The name of the file to report when an error occurs
  * @param {string} input
- * @returns {Record<string, any> | null}
+ * @returns {PageOptions | null}
  */
 export function statically_analyse_page_options(filename, input) {
-	// if there's a chance there are no page exports or export all declaration,
-	// then we can skip the AST parsing which is expensive
+	// if there's a chance there are no page exports or an unparseable
+	// export all declaration, then we can skip the AST parsing which is expensive
 	if (!skip_parsing_regex.test(input)) {
 		return {};
 	}
@@ -194,33 +206,56 @@ export function statically_analyse_page_options(filename, input) {
  * @param {import('acorn').Identifier | import('acorn').Literal} node
  * @returns {string}
  */
-export function get_name(node) {
+function get_name(node) {
 	return node.type === 'Identifier' ? node.name : /** @type {string} */ (node.value);
 }
 
 /**
- * @param {{
- *   resolve: (file: string) => Promise<Record<string, any>>;
- *   static_exports?: Map<string, { page_options: Record<string, any> | null, children: string[] }>;
- * }} opts
+ * Reads and statically analyses a file for page options
+ * @param {string} filepath
+ * @returns {PageOptions | null} Returns the page options for the file or `null` if unanalysable
  */
-export function create_node_analyser({ resolve, static_exports = new Map() }) {
+export function get_page_options(filepath) {
+	try {
+		const input = read(filepath);
+		const page_options = statically_analyse_page_options(filepath, input);
+		if (page_options === null) {
+			return null;
+		}
+
+		return page_options;
+	} catch {
+		return null;
+	}
+}
+
+export function create_node_analyser() {
+	const static_exports = new Map();
+
+	/**
+	 * @param {string | undefined} key
+	 * @param {PageOptions | null} page_options
+	 */
+	const cache = (key, page_options) => {
+		if (key) static_exports.set(key, { page_options, children: [] });
+	};
+
 	/**
 	 * Computes the final page options (may include load function as `load: null`; special case) for a node (if possible). Otherwise, returns `null`.
 	 * @param {import('types').PageNode} node
-	 * @returns {Promise<Record<string, any> | null>}
+	 * @returns {PageOptions | null}
 	 */
-	const get_page_options = async (node) => {
+	const crawl = (node) => {
 		const key = node.universal || node.server;
 		if (key && static_exports.has(key)) {
 			return { ...static_exports.get(key)?.page_options };
 		}
 
-		/** @type {Record<string, any>} */
+		/** @type {PageOptions} */
 		let page_options = {};
 
 		if (node.parent) {
-			const parent_options = await get_page_options(node.parent);
+			const parent_options = crawl(node.parent);
 
 			const parent_key = node.parent.universal || node.parent.server;
 			if (key && parent_key) {
@@ -230,9 +265,7 @@ export function create_node_analyser({ resolve, static_exports = new Map() }) {
 			if (parent_options === null) {
 				// if the parent cannot be analysed, we can't know what page options
 				// the child node inherits, so we also mark it as unanalysable
-				if (key) {
-					static_exports.set(key, { page_options: null, children: [] });
-				}
+				cache(key, null);
 				return null;
 			}
 
@@ -240,43 +273,29 @@ export function create_node_analyser({ resolve, static_exports = new Map() }) {
 		}
 
 		if (node.server) {
-			const module = await resolve(node.server);
-			for (const page_option in inheritable_page_options) {
-				if (page_option in module) {
-					page_options[page_option] = module[page_option];
-				}
+			const server_page_options = get_page_options(node.server);
+			if (server_page_options === null) {
+				cache(key, null);
+				return null;
 			}
+			page_options = { ...page_options, ...server_page_options };
 		}
 
 		if (node.universal) {
-			const input = read(node.universal);
-			const universal_page_options = statically_analyse_page_options(node.universal, input);
-
+			const universal_page_options = get_page_options(node.universal);
 			if (universal_page_options === null) {
-				static_exports.set(node.universal, { page_options: null, children: [] });
+				cache(key, null);
 				return null;
 			}
-
 			page_options = { ...page_options, ...universal_page_options };
 		}
 
-		if (key) {
-			static_exports.set(key, { page_options, children: [] });
-		}
+		cache(key, page_options);
 
 		return page_options;
 	};
 
-	/**
-	 * @param {string} file
-	 */
-	const invalidate_page_options = (file) => {
-		static_exports.get(file)?.children.forEach((child) => static_exports.delete(child));
-		static_exports.delete(file);
-	};
-
 	return {
-		get_page_options,
-		invalidate_page_options
+		get_page_options: crawl
 	};
 }

package/src/exports/vite/static_analysis/utils.js

@@ -1,3 +1,20 @@
+/**
+ * Check if content has children rendering (slot, @render, or children prop forwarding)
+ * @param {string} content - The markup content
+ * @param {boolean} is_svelte_5_plus - Whether the project uses Svelte 5+
+ * @returns {boolean}
+ */
+export function has_children(content, is_svelte_5_plus) {
+	return (
+		content.includes('<slot') ||
+		(is_svelte_5_plus &&
+			(content.includes('{@render') ||
+				// children may be forwarded to a child component as a prop
+				content.includes('{children}') ||
+				content.includes('children={')))
+	);
+}
+
 /**
  * Check if a match position is within a comment or a string
  * @param {string} content - The full content