@sveltejs/kit 3.0.0-next.2 → 3.0.0-next.21

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

@@ -1,4 +1,4 @@
-import { lookup } from 'mrmime';
+import { lookup } from '../../../utils/mime.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { styleText } from 'node:util';
@@ -29,35 +29,54 @@ export default function create_manifest_data({
 }) {
 	const assets = create_assets(config);
 	const hooks = create_hooks(config, cwd);
-	const matchers = create_matchers(config, cwd);
+	const params = resolve_params(config, cwd);
 	const { nodes, routes } = create_routes_and_nodes(cwd, config, fallback);
 
-	// validate matcher names used in parameterised routes
-	for (const route of routes) {
-		for (const param of route.params) {
-			if (param.matcher && !matchers[param.matcher]) {
-				throw new Error(`No matcher found for parameter '${param.matcher}' in route ${route.id}`);
-			}
-		}
-	}
-
 	return {
 		assets,
 		hooks,
-		matchers,
+		params,
 		nodes,
 		routes
 	};
 }
 
+/**
+ * Whether this route has a `+page`. Independent of `is_endpoint_route` — a route can be both.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_page_route(route) {
+	return !!route.page;
+}
+
+/**
+ * Whether this route has a `+server`. Independent of `is_page_route` — a route can be both.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_endpoint_route(route) {
+	return !!route.endpoint;
+}
+
+/**
+ * Whether the router can match this route. `manifest_data.routes` also contains entries for
+ * directories with layouts or errors, which never reach `event.route.id`.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_app_route(route) {
+	return is_page_route(route) || is_endpoint_route(route);
+}
+
 /**
  * Returns a list of files in the `static` directory.
  * @param {import('types').ValidatedConfig} config
  */
 export function create_assets(config) {
-	return list_files(config.kit.files.assets).map((file) => ({
+	return list_files(config.files.assets).map((file) => ({
 		file,
-		size: fs.statSync(path.resolve(config.kit.files.assets, file)).size,
+		size: fs.statSync(path.resolve(config.files.assets, file)).size,
 		type: lookup(file) || null
 	}));
 }
@@ -67,9 +86,9 @@ export function create_assets(config) {
  * @param {string} cwd
  */
 function create_hooks(config, cwd) {
-	const client = resolve_entry(config.kit.files.hooks.client);
-	const server = resolve_entry(config.kit.files.hooks.server);
-	const universal = resolve_entry(config.kit.files.hooks.universal);
+	const client = resolve_entry(config.files.hooks.client);
+	const server = resolve_entry(config.files.hooks.server);
+	const universal = resolve_entry(config.files.hooks.universal);
 
 	return {
 		client: client && posixify(path.relative(cwd, client)),
@@ -82,38 +101,9 @@ function create_hooks(config, cwd) {
  * @param {import('types').ValidatedConfig} config
  * @param {string} cwd
  */
-function create_matchers(config, cwd) {
-	const params_base = path.relative(cwd, config.kit.files.params);
-
-	/** @type {Record<string, string>} */
-	const matchers = {};
-	if (fs.existsSync(config.kit.files.params)) {
-		for (const file of fs.readdirSync(config.kit.files.params)) {
-			const ext = path.extname(file);
-			if (!config.kit.moduleExtensions.includes(ext)) continue;
-			const type = file.slice(0, -ext.length);
-
-			if (/^\w+$/.test(type)) {
-				const matcher_file = path.join(params_base, file);
-
-				// Disallow same matcher with different extensions
-				if (matchers[type]) {
-					throw new Error(`Duplicate matchers: ${matcher_file} and ${matchers[type]}`);
-				} else {
-					matchers[type] = matcher_file;
-				}
-			} else {
-				// Allow for matcher test collocation
-				if (type.endsWith('.test') || type.endsWith('.spec')) continue;
-
-				throw new Error(
-					`Matcher names can only have underscores and alphanumeric characters — "${file}" is invalid`
-				);
-			}
-		}
-	}
-
-	return matchers;
+function resolve_params(config, cwd) {
+	const params_file = resolve_entry(config.files.params);
+	return params_file ? posixify(path.relative(cwd, params_file)) : null;
 }
 
 /**
@@ -123,17 +113,17 @@ function create_matchers(config, cwd) {
  */
 function create_routes_and_nodes(cwd, config, fallback) {
 	/** @type {import('types').RouteData[]} */
-	const routes = [];
+	let routes = [];
 
-	const routes_base = posixify(path.relative(cwd, config.kit.files.routes));
+	const routes_base = posixify(path.relative(cwd, config.files.routes));
 
-	const valid_extensions = [...config.extensions, ...config.kit.moduleExtensions];
+	const valid_extensions = [...config.extensions, ...config.moduleExtensions];
 
 	/** @type {import('types').PageNode[]} */
 	const nodes = [];
 
 	// create route data by processing files in `src/routes`
-	if (fs.existsSync(config.kit.files.routes)) {
+	if (fs.existsSync(config.files.routes)) {
 		/**
 		 * @param {number} depth
 		 * @param {string} id
@@ -163,7 +153,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 						);
 					}
 
-					return String.fromCharCode(parseInt(code, 16));
+					return String.fromCodePoint(parseInt(code, 16));
 				}
 			});
 
@@ -180,7 +170,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 				throw new Error(`Route ${id} should be renamed to ${id.replace(/#/g, '[x+23]')}`);
 			}
 
-			if (/\[\.\.\.\w+\]\/\[\[/.test(id)) {
+			if (/\[\.\.\.[\w-]+\]\/\[\[/.test(id)) {
 				throw new Error(
 					`Invalid route ${id} — an [[optional]] route segment cannot follow a [...rest] route segment`
 				);
@@ -221,10 +211,17 @@ function create_routes_and_nodes(cwd, config, fallback) {
 
 			// We can't use withFileTypes because of a NodeJs bug which returns wrong results
 			// with isDirectory() in case of symlinks: https://github.com/nodejs/node/issues/30646
-			const files = fs.readdirSync(dir).map((name) => ({
-				is_dir: fs.statSync(path.join(dir, name)).isDirectory(),
-				name
-			}));
+			// We sort the entries because `readdirSync` order is not guaranteed and differs
+			// between runtimes (e.g. Node returns entries alphabetically, Bun in directory
+			// order). Node indices are assigned from this traversal order, so without sorting
+			// the SSR and client manifests can disagree, causing hydration mismatches.
+			const files = fs
+				.readdirSync(dir)
+				.sort()
+				.map((name) => ({
+					is_dir: fs.statSync(path.join(dir, name)).isDirectory(),
+					name
+				}));
 
 			// process files first
 			for (const file of files) {
@@ -254,6 +251,15 @@ function create_routes_and_nodes(cwd, config, fallback) {
 					continue;
 				}
 
+				// allow e.g. `+page.stories.svelte` or `+server.test.ts`
+				if (
+					file.name.includes('.test.') ||
+					file.name.includes('.spec.') ||
+					file.name.includes('.stories.')
+				) {
+					continue;
+				}
+
 				if (file.name.endsWith('.d.ts')) {
 					let name = file.name.slice(0, -5);
 					const ext = valid_extensions.find((ext) => name.endsWith(ext));
@@ -274,10 +280,10 @@ function create_routes_and_nodes(cwd, config, fallback) {
 					project_relative,
 					file.name,
 					config.extensions,
-					config.kit.moduleExtensions
+					config.moduleExtensions
 				);
 
-				if (config.kit.router.type === 'hash' && item.kind === 'server') {
+				if (config.router.type === 'hash' && item.kind === 'server') {
 					throw new Error(
 						`Cannot use server-only files in an app with \`router.type === 'hash': ${project_relative}`
 					);
@@ -368,7 +374,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 			const root = routes[0];
 			if (!root.leaf && !root.error && !root.layout && !root.endpoint) {
 				throw new Error(
-					'No routes found. If you are using a custom src/routes directory, make sure it is specified in your Svelte config file'
+					'No routes found. If you are using a custom src/routes directory, make sure it is specified in your SvelteKit Vite plugin options'
 				);
 			}
 		}
@@ -471,6 +477,9 @@ function create_routes_and_nodes(cwd, config, fallback) {
 		}
 	}
 
+	// remove route objects with no route file
+	routes = routes.filter((route) => route.endpoint || route.leaf || route.layout || route.error);
+
 	// add parents to error nodes so that we can compute which page options apply to them
 	for (const route of routes) {
 		if (!route.error) continue;
@@ -495,6 +504,17 @@ function create_routes_and_nodes(cwd, config, fallback) {
 		if (route.endpoint) {
 			route.endpoint.page_options = get_page_options(route.endpoint.file, cwd);
 		}
+
+		if (route.page && route.endpoint) {
+			const page = nodes[route.page.leaf];
+			if (page.page_options?.prerender || route.endpoint.page_options?.prerender) {
+				const endpoint_file = route.endpoint.file.split('/').pop();
+
+				throw new Error(
+					`Cannot prerender a route (${route.id}) with both a \`+page.svelte\` and a \`${endpoint_file}\``
+				);
+			}
+		}
 	}
 
 	return {

package/src/core/sync/sync.js

@@ -1,12 +1,9 @@
 import path from 'node:path';
-import process from 'node:process';
 import create_manifest_data from './create_manifest_data/index.js';
 import { write_client_manifest } from './write_client_manifest.js';
-import { write_root } from './write_root.js';
-import { write_tsconfig } from './write_tsconfig.js';
+import { write_tsconfig } from './write_tsconfig/index.js';
 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_app_types } from './write_app_types.js';
 import { write_server } from './write_server.js';
 import {
 	create_node_analyser,
@@ -21,8 +18,7 @@ import { write_env } from './write_env.js';
  * @param {string} root The project root directory
  */
 export function init(config, root) {
-	write_tsconfig(config.kit, root);
-	write_ambient(config.kit);
+	write_tsconfig(config, root);
 }
 
 /**
@@ -33,13 +29,12 @@ export function init(config, root) {
 export function create(config, root) {
 	const manifest_data = create_manifest_data({ config, cwd: root });
 
-	const output = path.join(config.kit.outDir, 'generated');
+	const output = path.join(config.outDir, 'generated');
 
-	write_client_manifest(config.kit, manifest_data, `${output}/client`);
+	write_client_manifest(config, manifest_data, `${output}/client`);
 	write_server(config, output, root);
-	write_root(manifest_data, config, output);
 	write_all_types(config, manifest_data, root);
-	write_non_ambient(config.kit, manifest_data);
+	write_app_types(config, manifest_data, root);
 
 	return { manifest_data };
 }
@@ -52,22 +47,35 @@ export function create(config, root) {
  * @param {import('types').ManifestData} manifest_data
  * @param {string} file
  * @param {string} root The project root directory
+ * @returns {boolean} Whether the update completed, or a full manifest rebuild is needed
  */
 export function update(config, manifest_data, file, root) {
-	const node_analyser = create_node_analyser(root);
+	try {
+		const node_analyser = create_node_analyser(root);
 
-	for (const node of manifest_data.nodes) {
-		node.page_options = node_analyser.get_page_options(node);
-	}
+		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, root);
+			}
+		}
 
-	for (const route of manifest_data.routes) {
-		if (route.endpoint) {
-			route.endpoint.page_options = get_page_options(route.endpoint.file, root);
+		write_types(config, manifest_data, file, root);
+		write_app_types(config, manifest_data, root);
+	} catch (error) {
+		// A route file can disappear before the watcher delivers its unlink event. In that case,
+		// the manifest is stale and must be rebuilt instead of incrementally updated.
+		if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+			return false;
 		}
+
+		throw error;
 	}
 
-	write_types(config, manifest_data, file, root);
-	write_non_ambient(config.kit, manifest_data);
+	return true;
 }
 
 /**
@@ -83,26 +91,27 @@ export function all(config, root) {
 /**
  * Run sync.init and then generate all type files.
  * @param {import('types').ValidatedConfig} config
+ * @param {string} root
  */
-export function all_types(config) {
-	const cwd = process.cwd();
-	init(config, cwd);
-	const manifest_data = create_manifest_data({ config, cwd });
-	write_all_types(config, manifest_data, cwd);
-	write_non_ambient(config.kit, manifest_data);
+export function all_types(config, root) {
+	init(config, root);
+	const manifest_data = create_manifest_data({ config, cwd: root });
+	write_all_types(config, manifest_data, root);
+	write_app_types(config, manifest_data, root);
 }
 
 /**
  * Generate modules and types for explicit env vars
- * @param {import('types').ValidatedKitConfig} kit
+ * @param {typeof import('vite')} vite
+ * @param {import('types').ValidatedConfig} kit
  * @param {string | null} entry
  * @param {string} root The Vite root
  * @param {string} mode The Vite mode
  */
-export async function env(kit, entry, root, mode) {
-	const env_config = await load_explicit_env(kit, entry, root, mode);
+export async function env(vite, kit, entry, root, mode) {
+	const env_config = await load_explicit_env(vite, kit, entry, root, mode);
 
-	write_env(kit, entry, env_config);
+	write_env(entry, env_config, root);
 
 	return env_config;
 }
@@ -113,5 +122,5 @@ export async function env(kit, entry, root, mode) {
  * @param {string} root The project root directory
  */
 export function server(config, root) {
-	write_server(config, path.join(config.kit.outDir, 'generated'), root);
+	write_server(config, path.join(config.outDir, 'generated'), root);
 }

package/src/core/sync/ts.js

@@ -1,4 +1,4 @@
-/** @type {import('typescript')} */
+/** @type {typeof import('typescript')} */
 // @ts-ignore
 export let ts = undefined;
 try {

package/src/core/sync/utils.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { mkdirp } from '../../utils/filesystem.js';
+import { styleText } from 'node:util';
+import { resolve_entry } from '../../utils/filesystem.js';
 
 /** @type {Map<string, string>} */
 const previous_contents = new Map();
@@ -21,7 +22,7 @@ export function write_if_changed(file, code) {
  */
 export function write(file, code) {
 	previous_contents.set(file, code);
-	mkdirp(path.dirname(file));
+	fs.mkdirSync(path.dirname(file), { recursive: true });
 	fs.writeFileSync(file, code);
 }
 
@@ -68,3 +69,22 @@ export function dedent(strings, ...values) {
 
 	return str;
 }
+
+/**
+ * @param {string} original
+ * @param {string} typo The common misspelling to check for
+ * @param {string} description What was wrong with the filename
+ */
+export function check_spelling(original, typo, description) {
+	const misspelled = resolve_entry(typo);
+	if (!misspelled) return;
+
+	const corrected = path.basename(misspelled).replace(path.basename(typo), path.basename(original));
+
+	console.warn(
+		styleText(
+			['bold', 'yellow'],
+			`${description}. Did you mean ${corrected}?` + ` at ${path.resolve(misspelled)}`
+		)
+	);
+}