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

package/src/core/sync/{write_non_ambient.js → write_app_types.js}

@@ -1,17 +1,45 @@
 import path from 'node:path';
 import { GENERATED_COMMENT } from '../../constants.js';
+import { resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { write_if_changed } from './utils.js';
 import { s } from '../../utils/misc.js';
-import { get_route_segments } from '../../utils/routing.js';
-
-const replace_optional_params = (/** @type {string} */ id) =>
-	id.replace(/\/\[\[[^\]]+\]\]/g, '${string}');
-const replace_required_params = (/** @type {string} */ id) =>
-	id.replace(/\/\[[^\]]+\]/g, '/${string}');
-/** Convert route ID to pathname by removing layout groups */
-const remove_group_segments = (/** @type {string} */ id) => {
-	return '/' + get_route_segments(id).join('/');
+import {
+	decode_escape_sequence,
+	encode_pathname_chars,
+	get_route_segments,
+	segment_pattern
+} from '../../utils/routing.js';
+import { is_app_route, is_endpoint_route, is_page_route } from './create_manifest_data/index.js';
+
+const optional_param_pattern = /^\[\[[\w-]+(?:=[\w-]+)?\]\]$/;
+const rest_param_pattern = /^\[\.\.\.[\w-]+(?:=[\w-]+)?\]$/;
+
+/**
+ * Convert a route ID to the pathnames it can match (relative to the base path), in which each
+ * param is replaced with `${string}` and each escape sequence is expanded. A param that fills an
+ * entire segment can be absent, so it contributes a pathname with the segment and one without,
+ * rather than one that absorbs the `/`
+ * @param {string} id
+ */
+const get_pathname_patterns = (id) => {
+	let pathnames = [''];
+
+	for (const segment of get_route_segments(id)) {
+		const omittable = optional_param_pattern.test(segment) || rest_param_pattern.test(segment);
+		const content = omittable
+			? '${string}'
+			: segment.replace(segment_pattern, (_, escape_type, escape_code) =>
+					escape_type ? encode_pathname_chars(decode_escape_sequence(escape_code)) : '${string}'
+				);
+
+		pathnames = pathnames.flatMap((pathname) => {
+			const joined = pathname === '' ? content : `${pathname}/${content}`;
+			return omittable ? [joined, pathname] : [joined];
+		});
+	}
+
+	return [...new Set(pathnames)];
 };
 
 /**
@@ -21,10 +49,6 @@ const remove_group_segments = (/** @type {string} */ id) => {
  * @returns {string[]}
  */
 function get_pathnames_for_trailing_slash(pathname, route) {
-	if (pathname === '/') {
-		return [pathname];
-	}
-
 	/** @type {Set<string>} */
 	const pathnames = new Set();
 
@@ -54,12 +78,8 @@ function get_pathnames_for_trailing_slash(pathname, route) {
 // people could use to type their own components.
 // The T generic is needed or else there's a "all declarations must have identical type parameters" error.
 const template = `
-${GENERATED_COMMENT}
-
 declare module "svelte/elements" {
 	export interface HTMLAttributes<T> {
-		'data-sveltekit-keepfocus'?: true | false | '' | undefined | null;
-		'data-sveltekit-noscroll'?: true | false | '' | undefined | null;
 		'data-sveltekit-preload-code'?:
 			| true
 			| false
@@ -73,22 +93,18 @@ declare module "svelte/elements" {
 		'data-sveltekit-preload-data'?: true | false | '' | 'hover' | 'tap' | undefined | null;
 		'data-sveltekit-reload'?: true | false | '' | undefined | null;
 		'data-sveltekit-replacestate'?: true | false | '' | undefined | null;
+		'data-sveltekit-reset'?: true | false | '' | undefined | null;
 	}
 }
-
-export {};
 `;
 
 /**
  * Generate app types interface extension
  * @param {import('types').ManifestData} manifest_data
- * @param {import('types').ValidatedKitConfig} config
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} dir
  */
-function generate_app_types(manifest_data, config) {
-	/** @param {string} matcher */
-	const path_to_matcher = (matcher) =>
-		posixify(path.relative(config.outDir, path.join(config.files.params, matcher + '.js')));
-
+function generate_app_types(manifest_data, config, dir) {
 	/** @type {Map<string, string>} */
 	const matcher_types = new Map();
 
@@ -98,7 +114,15 @@ function generate_app_types(manifest_data, config) {
 
 		let type = matcher_types.get(matcher);
 		if (!type) {
-			type = `MatcherParam<typeof import('${path_to_matcher(matcher)}').match>`;
+			const path_to_params = () => {
+				const params_file =
+					resolve_entry(config.files.params) ??
+					config.files.params.replace(/\.(js|ts)$/, '') + '.js';
+
+				return posixify(path.relative(dir, params_file));
+			};
+
+			type = `import('@sveltejs/kit/params').MatcherParam<(typeof import('${path_to_params()}').params)[${JSON.stringify(matcher)}]>`;
 			matcher_types.set(matcher, type);
 		}
 
@@ -145,6 +169,15 @@ function generate_app_types(manifest_data, config) {
 	/** @type {Set<string>} */
 	const pathnames = new Set();
 
+	/** @type {string[]} */
+	const page_route_ids = [];
+
+	/** @type {string[]} */
+	const endpoint_route_ids = [];
+
+	/** @type {string[]} */
+	const app_route_ids = [];
+
 	/** @type {string[]} */
 	const dynamic_routes = [];
 
@@ -153,15 +186,17 @@ function generate_app_types(manifest_data, config) {
 
 	/** @type {Map<string, Map<string, { optional: boolean, matchers: Set<string> | null }>>} */
 	const layout_params_by_route = new Map(
-		manifest_data.routes.map((route) => [
-			route.id,
-			new Map(
-				route.params.map((p) => [
-					p.name,
-					{ optional: p.optional, matchers: p.matcher ? new Set([p.matcher]) : null }
-				])
-			)
-		])
+		manifest_data.routes
+			.filter((route) => route.layout)
+			.map((route) => [
+				route.id,
+				new Map(
+					route.params.map((p) => [
+						p.name,
+						{ optional: p.optional, matchers: p.matcher ? new Set([p.matcher]) : null }
+					])
+				)
+			])
 	);
 
 	for (const route of manifest_data.routes) {
@@ -195,8 +230,11 @@ function generate_app_types(manifest_data, config) {
 	}
 
 	for (const route of manifest_data.routes) {
-		const pathname = remove_group_segments(route.id);
-		let normalized_pathname = pathname;
+		const id = s(route.id);
+
+		if (is_page_route(route)) page_route_ids.push(id);
+		if (is_endpoint_route(route)) endpoint_route_ids.push(id);
+		if (is_app_route(route)) app_route_ids.push(id);
 
 		/** @type {(path: string) => string} */
 		let serialise = s;
@@ -204,18 +242,20 @@ function generate_app_types(manifest_data, config) {
 		if (route.params.length > 0) {
 			const params = route.params.map((p) => {
 				const type = get_matcher_type(p.matcher);
-				return `${p.name}${p.optional ? '?:' : ':'} ${type}${p.optional ? ' | undefined' : ''}`;
+				return `${/^\w+$/.test(p.name) ? p.name : `'${p.name}'`}${p.optional ? '?:' : ':'} ${type}${p.optional ? ' | undefined' : ''}`;
 			});
-			const route_type = `${s(route.id)}: { ${params.join('; ')} }`;
 
-			dynamic_routes.push(route_type);
+			if (is_app_route(route)) {
+				dynamic_routes.push(`${s(route.id)}: { ${params.join('; ')} }`);
+			}
 
-			normalized_pathname = replace_required_params(replace_optional_params(pathname));
 			serialise = (p) => `\`${p}\` & {}`;
 		}
 
-		for (const p of get_pathnames_for_trailing_slash(normalized_pathname, route)) {
-			pathnames.add(serialise(p));
+		for (const pathname of get_pathname_patterns(route.id)) {
+			for (const p of get_pathnames_for_trailing_slash(pathname, route)) {
+				pathnames.add(serialise(p));
+			}
 		}
 
 		let layout_type = 'Record<string, never>';
@@ -225,42 +265,51 @@ function generate_app_types(manifest_data, config) {
 			const params = Array.from(layout_params)
 				.map(([name, { optional, matchers }]) => {
 					const type = get_matchers_type(matchers);
-					return `${name}${optional ? '?:' : ':'} ${type}${optional ? ' | undefined' : ''}`;
+					return `${/^\w+$/.test(name) ? name : `'${name}'`}${optional ? '?:' : ':'} ${type}${optional ? ' | undefined' : ''}`;
 				})
 				.join('; ');
 
 			if (params.length > 0) layout_type = `{ ${params} }`;
 		}
 
-		layouts.push(`${s(route.id)}: ${layout_type}`);
+		if (route.layout) layouts.push(`${s(route.id)}: ${layout_type}`);
 	}
 
-	const assets = manifest_data.assets.map((asset) => s('/' + asset.file));
+	const assets = manifest_data.assets.map((asset) => s(asset.file));
 
 	return [
 		'declare module "$app/types" {',
-		'\ttype MatcherParam<M> = M extends (param : string) => param is (infer U extends string) ? U : string;',
-		'',
 		'\texport interface AppTypes {',
-		`\t\tRouteId(): ${manifest_data.routes.map((r) => s(r.id)).join(' | ')};`,
+		`\t\tPageRouteId(): ${page_route_ids.join(' | ') || 'never'};`,
+		`\t\tEndpointRouteId(): ${endpoint_route_ids.join(' | ') || 'never'};`,
+		`\t\tRouteId(): ${app_route_ids.join(' | ') || 'never'};`,
 		`\t\tRouteParams(): {\n\t\t\t${dynamic_routes.join(';\n\t\t\t')}\n\t\t};`,
 		`\t\tLayoutParams(): {\n\t\t\t${layouts.join(';\n\t\t\t')}\n\t\t};`,
-		`\t\tPathname(): ${Array.from(pathnames).join(' | ')};`,
-		'\t\tResolvedPathname(): `${"" | `/${string}`}${ReturnType<AppTypes[\'Pathname\']>}`;',
-		`\t\tAsset(): ${assets.concat('string & {}').join(' | ')};`,
+		`\t\tPath(): ${Array.from(pathnames).join(' | ')};`,
+		'\t\tResolvedPathname(): `${"/" | `/${string}/`}${ReturnType<AppTypes[\'Path\']>}`;',
+		`\t\tAssetPath(): ${assets.join(' | ') || 'never'};`,
 		'\t}',
 		'}'
 	].join('\n');
 }
 
 /**
- * Writes non-ambient declarations to the output directory
- * @param {import('types').ValidatedKitConfig} config
+ * Writes `node_modules/$app/types/index.d.ts`. This file contains
+ * declarations for `$app/types` and `svelte/elements`, and
+ * imports `env.ts` which declares `$app/env/(public|private)`
+ * @param {import('types').ValidatedConfig} config
  * @param {import('types').ManifestData} manifest_data
+ * @param {string} root
  */
-export function write_non_ambient(config, manifest_data) {
-	const app_types = generate_app_types(manifest_data, config);
-	const content = [template, app_types].join('\n\n');
+export function write_app_types(config, manifest_data, root) {
+	const dir = path.join(root, 'node_modules/$app/types');
+
+	const content = [
+		GENERATED_COMMENT,
+		`import '@sveltejs/kit';\nimport './env';`,
+		generate_app_types(manifest_data, config, dir),
+		template.trim()
+	].join('\n\n');
 
-	write_if_changed(path.join(config.outDir, 'non-ambient.d.ts'), content);
+	write_if_changed(path.join(dir, 'index.d.ts'), content);
 }

package/src/core/sync/write_client_manifest.js

@@ -1,13 +1,11 @@
-import path from 'node:path';
-import { styleText } from 'node:util';
+import { check_spelling, dedent, write_if_changed } from './utils.js';
 import { relative_path, resolve_entry } from '../../utils/filesystem.js';
 import { s } from '../../utils/misc.js';
-import { dedent, write_if_changed } from './utils.js';
 
 /**
  * Writes the client manifest to disk. The manifest is used to power the router. It contains the
  * list of routes and corresponding Svelte components (i.e. pages and layouts).
- * @param {import('types').ValidatedKitConfig} kit
+ * @param {import('types').ValidatedConfig} kit
  * @param {import('types').ManifestData} manifest_data
  * @param {string} output
  * @param {import('types').ServerMetadata['nodes']} [metadata] If this is omitted, we have to assume that all routes with a `+layout/page.server.js` file have a server load function
@@ -123,15 +121,9 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 	const client_hooks_file = resolve_entry(kit.files.hooks.client);
 	const universal_hooks_file = resolve_entry(kit.files.hooks.universal);
 
-	const typo = resolve_entry('src/+hooks.client');
-	if (typo) {
-		console.log(
-			styleText(
-				['bold', 'yellow'],
-				`Unexpected + prefix. Did you mean ${typo.split('/').at(-1)?.slice(1)}?` +
-					` at ${path.resolve(typo)}`
-			)
-		);
+	if (!client_hooks_file) {
+		check_spelling('src/hooks.client', 'src/+hooks.client', 'Unexpected + prefix');
+		check_spelling('src/hooks.client', 'src/hook.client', 'Missing s suffix');
 	}
 
 	// Stringified version of
@@ -163,7 +155,7 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 			export const hooks = {
 				handleError: ${
 					client_hooks_file ? 'client_hooks.handleError || ' : ''
-				}(({ error }) => { console.error(error) }),
+				}(({ kind, error }) => { if (kind === 'unknown') { console.error(error); } }),
 				${client_hooks_file ? 'init: client_hooks.init,' : ''}
 				reroute: ${universal_hooks_file ? 'universal_hooks.reroute || ' : ''}(() => {}),
 				transport: ${universal_hooks_file ? 'universal_hooks.transport || ' : ''}{}
@@ -176,26 +168,19 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 
 			export const decode = (type, value) => decoders[type](value);
 
-			export { default as root } from '../root.js';
+			export const get_error_template = () => import('../shared/error-template.js').then(m => m.default);
 		`
 	);
 
 	if (client_routing) {
-		// write matchers to a separate module so that we don't
-		// need to worry about name conflicts
-		const imports = [];
-		const matchers = [];
-
-		for (const key in manifest_data.matchers) {
-			const src = manifest_data.matchers[key];
-
-			imports.push(`import { match as ${key} } from ${s(relative_path(output, src))};`);
-			matchers.push(key);
-		}
+		const uses_matchers = manifest_data.routes.some((route) =>
+			route.params.some((param) => param.matcher)
+		);
 
-		const module = imports.length
-			? `${imports.join('\n')}\n\nexport const matchers = { ${matchers.join(', ')} };`
-			: 'export const matchers = {};';
+		const module =
+			!manifest_data.params || !uses_matchers
+				? 'export const matchers = {};'
+				: `import { params as matchers } from ${s(relative_path(output, manifest_data.params))};\n\nexport { matchers };`;
 
 		write_if_changed(`${output}/matchers.js`, module);
 	}

package/src/core/sync/write_env.js

@@ -1,4 +1,4 @@
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
+/** @import { EnvVarConfig } from '@sveltejs/kit/env' */
 import path from 'node:path';
 import { create_explicit_env_types } from '../env.js';
 import { write_if_changed } from './utils.js';
@@ -10,16 +10,18 @@ const DOCS = '// See https://svelte.dev/docs/kit/environment-variables for more
  * Writes ambient declarations including types reference to @sveltejs/kit,
  * and the existing environment variables in process.env to
  * $env/static/private and $env/static/public
- * @param {import('types').ValidatedKitConfig} kit
  * @param {string | null} entry
  * @param {Record<string, EnvVarConfig<any>> | null} env_config
+ * @param {string} root
  */
-export function write_env(kit, entry, env_config) {
+export function write_env(entry, env_config, root) {
 	const content = [];
-	const out = path.join(kit.outDir, 'env.d.ts');
+
+	const dir = path.join(root, 'node_modules/$app/types');
+	const out = path.join(dir, 'env.d.ts');
 
 	if (entry && env_config) {
-		const relative = posixify(path.relative(kit.outDir, entry));
+		const relative = posixify(path.relative(dir, entry));
 		content.push(
 			`// This file is generated from ${relative}.\n${DOCS}`,
 			create_explicit_env_types(env_config, relative, 'private'),

package/src/core/sync/write_server.js

@@ -1,11 +1,10 @@
 import path from 'node:path';
-import { styleText } from 'node:util';
 import { hash } from '../../utils/hash.js';
 import { resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { s } from '../../utils/misc.js';
 import { load_error_page, load_template } from '../config/index.js';
-import { write_if_changed } from './utils.js';
+import { check_spelling, write_if_changed } from './utils.js';
 import { escape_html } from '../../utils/escape.js';
 
 /**
@@ -15,7 +14,6 @@ import { escape_html } from '../../utils/escape.js';
  *   config: import('types').ValidatedConfig;
  *   has_service_worker: boolean;
  *   template: string;
- *   error_page: string;
  * }} opts
  */
 const server_template = ({
@@ -23,54 +21,48 @@ const server_template = ({
 	server_hooks,
 	universal_hooks,
 	has_service_worker,
-	template,
-	error_page
+	template
 }) => `
-import root from '../root.js';
 import { set_building, set_prerendering } from '$app/env/internal';
 import { set_assets } from '$app/paths/internal/server';
-import { set_manifest, set_read_implementation } from '__sveltekit/server';
-import { set_env } from '__sveltekit/env';
+import { set_fix_stack_trace, set_manifest, set_read_implementation, log_response } from '__sveltekit/server';
+import error from '../shared/error-template.js';
 
 export const options = {
 	app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
-	async: ${s(!!config.compilerOptions?.experimental?.async)},
-	csp: ${s(config.kit.csp)},
-	csrf_check_origin: ${s(!config.kit.csrf.trustedOrigins.includes('*'))},
-	csrf_trusted_origins: ${s(config.kit.csrf.trustedOrigins)},
-	embedded: ${config.kit.embedded},
-	hash_routing: ${s(config.kit.router.type === 'hash')},
+	csp: ${s(config.csp)},
+	csrf_check_origin: ${s(!config.csrf.trustedOrigins.includes('*'))},
+	csrf_trusted_origins: ${s(config.csrf.trustedOrigins)},
+	embedded: ${config.embedded},
+	hash_routing: ${s(config.router.type === 'hash')},
 	hooks: null, // added lazily, via \`get_hooks\`
-	link_header_preload: ${s(config.kit.output.linkHeaderPreload)},
-	root,
+	link_header_preload: ${s(config.output.linkHeaderPreload)},
+	paths_origin: ${s(config.paths.origin)},
 	service_worker: ${has_service_worker},
-	service_worker_options: ${config.kit.serviceWorker.register ? s(config.kit.serviceWorker.options) : 'null'},
-	server_error_boundaries: ${s(!!config.kit.experimental.handleRenderingErrors)},
+	service_worker_options: ${config.serviceWorker.register ? s(config.serviceWorker.options) : 'null'},
 	templates: {
 		app: ({ head, body, assets, nonce, env }) => ${s(template)
 			.replace('%sveltekit.head%', '" + head + "')
 			.replace('%sveltekit.body%', '" + body + "')
 			.replace(/%sveltekit\.assets%/g, '" + assets + "')
 			.replace(/%sveltekit\.nonce%/g, '" + nonce + "')
-			.replace(/%sveltekit\.version%/g, escape_html(config.kit.version.name))
+			.replace(/%sveltekit\.version%/g, escape_html(config.version.name))
 			.replace(
 				/%sveltekit\.env\.([^%]+)%/g,
 				(_match, capture) => `" + (env[${s(capture)}] ?? "") + "`
 			)},
-		error: ({ status, message }) => ${s(error_page)
-			.replace(/%sveltekit\.status%/g, '" + status + "')
-			.replace(/%sveltekit\.error\.message%/g, '" + message + "')}
+		error
 	},
-	version_hash: ${s(hash(config.kit.version.name))}
+	version: ${s(config.version.name)},
+	version_hash: ${s(hash(config.version.name))}
 };
 
 export async function get_hooks() {
 	let handle;
 	let handleFetch;
 	let handleError;
-	let handleValidationError;
 	let init;
-	${server_hooks ? `({ handle, handleFetch, handleError, handleValidationError, init } = await import(${s(server_hooks)}));` : ''}
+	${server_hooks ? `({ handle, handleFetch, handleError, init } = await import(${s(server_hooks)}));` : ''}
 
 	let reroute;
 	let transport;
@@ -80,20 +72,15 @@ export async function get_hooks() {
 		handle,
 		handleFetch,
 		handleError,
-		handleValidationError,
 		init,
 		reroute,
 		transport
 	};
 }
 
-export { set_assets, set_building, set_env, set_manifest, set_prerendering, set_read_implementation };
+export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation, log_response };
 `;
 
-// TODO need to re-run this whenever src/app.html or src/error.html are
-// created or changed, or src/service-worker.js is created or deleted.
-// Also, need to check that updating hooks.server.js works
-
 /**
  * Write server configuration to disk
  * @param {import('types').ValidatedConfig} config
@@ -101,18 +88,17 @@ export { set_assets, set_building, set_env, set_manifest, set_prerendering, set_
  * @param {string} root The project root directory
  */
 export function write_server(config, output, root) {
-	const server_hooks_file = resolve_entry(config.kit.files.hooks.server);
-	const universal_hooks_file = resolve_entry(config.kit.files.hooks.universal);
+	const server_hooks_file = resolve_entry(config.files.hooks.server);
+	const universal_hooks_file = resolve_entry(config.files.hooks.universal);
+
+	if (!server_hooks_file) {
+		check_spelling('src/hooks.server', 'src/+hooks.server', 'Unexpected + prefix');
+		check_spelling('src/hooks.server', 'src/hook.server', 'Missing s suffix');
+	}
 
-	const typo = resolve_entry('src/+hooks.server');
-	if (typo) {
-		console.log(
-			styleText(
-				['bold', 'yellow'],
-				`Unexpected + prefix. Did you mean ${typo.split('/').at(-1)?.slice(1)}?` +
-					` at ${path.resolve(typo)}`
-			)
-		);
+	if (!universal_hooks_file) {
+		check_spelling('src/hooks', 'src/+hooks', 'Unexpected + prefix');
+		check_spelling('src/hooks', 'src/hook', 'Missing s suffix');
 	}
 
 	/** @param {string} file */
@@ -120,6 +106,13 @@ export function write_server(config, output, root) {
 		return posixify(path.relative(`${output}/server`, file));
 	}
 
+	write_if_changed(
+		`${output}/shared/error-template.js`,
+		`export default ({ status, message }) => ${s(load_error_page(config))
+			.replace(/%sveltekit\.status%/g, '" + status + "')
+			.replace(/%sveltekit\.error\.message%/g, '" + message + "')};`
+	);
+
 	// Contains the stringified version of
 	/** @type {import('types').SSROptions} */
 	write_if_changed(
@@ -129,9 +122,8 @@ export function write_server(config, output, root) {
 			server_hooks: server_hooks_file ? relative(server_hooks_file) : null,
 			universal_hooks: universal_hooks_file ? relative(universal_hooks_file) : null,
 			has_service_worker:
-				config.kit.serviceWorker.register && !!resolve_entry(config.kit.files.serviceWorker),
-			template: load_template(root, config),
-			error_page: load_error_page(config)
+				config.serviceWorker.register && !!resolve_entry(config.files.serviceWorker),
+			template: load_template(root, config)
 		})
 	);
 }