@sveltejs/kit 3.0.0-next.13 → 3.0.0-next.16

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

@@ -6,13 +6,12 @@ import { styleText } from 'node:util';
 import { write_if_changed } from '../utils.js';
 import {
 	ESSENTIAL_OPTIONS,
-	extends_id,
 	get_subpath_imports,
 	normalize_config,
 	RECOMMENDED_OPTIONS,
-	remove_trailing_slashstar,
-	validate_resolved_config
+	remove_trailing_slashstar
 } from './utils.js';
+import { extends_id, validate_resolved_config } from './validate.js';
 
 /** @type {import('typescript')} */
 let ts;
@@ -29,16 +28,16 @@ try {
  */
 export function write_tsconfig(kit, root) {
 	const paths = get_paths(kit, root);
+	const types = ['$app/types'];
 
 	write_parent_tsconfig(
-		root,
 		root,
 		'$app/tsconfig',
 		{
 			compilerOptions: {
 				paths,
 				rootDirs: ['.', `${kit.outDir}/types`],
-				types: ['$app/types'],
+				types,
 
 				// This is required for svelte-package to work as expected
 				// Can be overwritten
@@ -46,89 +45,109 @@ export function write_tsconfig(kit, root) {
 
 				...ESSENTIAL_OPTIONS,
 				...RECOMMENDED_OPTIONS
-			},
-			exclude: [kit.files.serviceWorker]
-		},
-		{
-			extends: '$app/tsconfig',
-			include: ['src']
+			}
 		},
 		kit.typescript.config
 	);
 
-	write_parent_tsconfig(
-		root,
-		kit.files.serviceWorker,
-		'$app/tsconfig/service-worker',
-		{
-			compilerOptions: {
-				paths,
-				types: ['$app/types'],
-				lib: ['ESNext', 'WebWorker'],
-				...ESSENTIAL_OPTIONS
-			}
-		},
-		{
+	validate_config(root, {
+		paths,
+		types,
+		exclusions: [kit.files.serviceWorker],
+		example: {
+			extends: '$app/tsconfig'
+		}
+	});
+
+	write_parent_tsconfig(root, '$app/tsconfig/service-worker', {
+		compilerOptions: {
+			paths,
+			types,
+			lib: ['ESNext', 'WebWorker'],
+			...ESSENTIAL_OPTIONS,
+			...RECOMMENDED_OPTIONS
+		}
+	});
+
+	validate_config(kit.files.serviceWorker, {
+		paths,
+		types,
+		example: {
 			extends: '$app/tsconfig/service-worker'
 		}
-	);
+	});
 }
 
 /**
  * Write a generated `tsconfig.json` inside `node_modules`, for the
  * user config to extend
  * @param {string} root The project root
- * @param {string} dir The directory to resolve a user config from
  * @param {string} id The id of the generated config
  * @param {any} config The contents of the generated tsconfig, with paths relative to `root`
- * @param {any} example What to print if the user config does _not_ extend the generated config
  * @param {ValidatedKitConfig['typescript']['config']} [transform] TODO get rid of this
  */
-function write_parent_tsconfig(root, dir, id, config, example, transform) {
-	const out_file = path.join(root, `node_modules/${id}/tsconfig.json`);
+function write_parent_tsconfig(root, id, config, transform) {
+	// simplified tsconfig resolvers (e.g. Playwright's) only find `${id}.json`, not `${id}/tsconfig.json`
+	const out_file = path.join(root, `node_modules/${id}.json`);
 
 	let normalized = normalize_config(out_file, config);
 	normalized = transform?.(normalized) ?? normalized;
 
 	write_if_changed(out_file, JSON.stringify(normalized, null, '\t'));
+}
 
+/**
+ * @param {string} dir The directory to resolve a user config from
+ * @param {Object} options
+ * @param {Record<string, string[]>} options.paths The expected paths
+ * @param {string[]} options.types The expected types
+ * @param {string[]} [options.exclusions] Files that should be excluded
+ * @param {any} options.example What to print if the user config does _not_ extend the generated config
+ */
+function validate_config(dir, options) {
 	if (!ts) {
 		// The user has not installed TypeScript. Skip validation of config.
 		return;
 	}
 
 	const user_config = load_user_tsconfig(dir);
+	if (!user_config || !modified_since_last_check(user_config.file)) return;
 
-	if (user_config && modified_since_last_check(user_config.file)) {
-		// now that we've written the parent config, we can resolve the
-		// user config and validate that nothing important was overwritten
-		if (!extends_id(user_config.options, id)) {
-			console.warn(
-				styleText(
-					['bold', 'yellow'],
-					`${path.relative(process.cwd(), user_config.file)} should extend SvelteKit's built-in configuration:`
-				)
-			);
+	// now that we've written the parent config, we can resolve the
+	// user config and validate that nothing important was overwritten
+	if (!extends_id(user_config.options, options.example.extends)) {
+		console.warn(
+			styleText(
+				['bold', 'yellow'],
+				`${path.relative(process.cwd(), user_config.file)} should extend SvelteKit's built-in configuration:`
+			)
+		);
 
-			console.warn(JSON.stringify(example, null, '  '));
+		console.warn(JSON.stringify(options.example, null, '  '));
 
-			return;
-		}
+		return;
+	}
 
-		const resolved = ts.parseJsonConfigFileContent(user_config.options, ts.sys, dir).options;
-		const warnings = validate_resolved_config(resolved, config.compilerOptions);
+	const resolved = ts.parseJsonConfigFileContent(user_config.options, ts.sys, dir);
 
-		if (warnings.length > 0) {
-			console.warn(
-				styleText(
-					['bold', 'yellow'],
-					`Found issues while validating ${path.relative(process.cwd(), user_config.file)}`
-				)
-			);
+	const warnings = validate_resolved_config(
+		dir,
+		resolved,
+		options.paths,
+		options.types,
+		options.exclusions
+	);
 
-			for (const warning of warnings) {
-				console.warn(`  - ${warning}`);
-			}
+	if (warnings.length > 0) {
+		console.warn(
+			styleText(
+				['bold', 'yellow'],
+				`Found issues while validating ${path.relative(process.cwd(), user_config.file)}`
+			)
+		);
+
+		for (const warning of warnings) {
+			console.warn(`  - ${warning}`);
 		}
 	}
 }

package/src/core/sync/write_tsconfig/utils.js

@@ -36,16 +36,6 @@ export const RECOMMENDED_OPTIONS = {
 	noEmit: true // prevent tsconfig error "overwriting input files" - Vite handles the build and ignores this
 };
 
-/**
- * Validates that a tsconfig contains `"extends": "<id>"`
- * @param {any} options
- * @param {string} id
- */
-export function extends_id(options, id) {
-	const o = options.extends;
-	return Array.isArray(o) ? o.includes(id) : o === id;
-}
-
 /**
  * Makes paths relative to the output file
  * @param {string} out
@@ -76,57 +66,6 @@ export function normalize_config(out, config, transform) {
 	return transform?.(normalized) ?? normalized;
 }
 
-/**
- * @param {any} resolved
- * @param {any} options
- */
-export function validate_resolved_config(resolved, options) {
-	const warnings = [];
-
-	const join = (/** @type {string[]} */ array) =>
-		array
-			.map((v) => JSON.stringify(v))
-			.join(', ')
-			.replace(/, ([^,]*)$/, ' and $1');
-
-	const missing_types = options.types?.filter(
-		(/** @type {string} */ type) => !resolved.types?.includes(type)
-	);
-
-	if (missing_types.length > 0) {
-		warnings.push(`"types" was overwritten. It must include ${join(missing_types)}`);
-	}
-
-	if (options.paths) {
-		/** @type {Set<string>} */
-		const mismatch = new Set();
-
-		for (const [k, expected] of Object.entries(options.paths)) {
-			const actual = resolved.paths?.[k]?.map((/** @type {string} */ x) =>
-				path.resolve(/** @type {string} */ (resolved.pathsBasePath), x)
-			);
-
-			if (JSON.stringify(expected) !== JSON.stringify(actual)) {
-				mismatch.add(remove_trailing_slashstar(k));
-			}
-		}
-
-		if (mismatch.size > 0) {
-			const joined = join([...mismatch]);
-
-			warnings.push(`"paths" was overwritten. Imports from ${joined} may not typecheck`);
-		}
-	}
-
-	for (const key in ESSENTIAL_OPTIONS) {
-		if (resolved[key] !== options[key]) {
-			warnings.push(`"${key}" was overwritten. It should be ${JSON.stringify(options[key])}`);
-		}
-	}
-
-	return warnings;
-}
-
 /**
  * @param {string} file
  */

package/src/core/sync/write_tsconfig/validate.js

@@ -0,0 +1,128 @@
+/** @import ts from 'typescript' */
+import path from 'node:path';
+import { ESSENTIAL_OPTIONS, remove_trailing_slashstar } from './utils.js';
+import { posixify } from '../../../utils/os.js';
+
+const formatter = new Intl.ListFormat('en-gb', { type: 'conjunction' });
+
+/**
+ * @param {string[]} things
+ */
+function join(things) {
+	return formatter.format(things.map((thing) => JSON.stringify(thing)));
+}
+
+/**
+ * @param {string} dir
+ * @param {ts.ParsedCommandLine} resolved
+ * @param {Record<string, string[]>} paths
+ * @param {string[]} types
+ * @param {string[]} [exclusions]
+ */
+export function validate_resolved_config(dir, resolved, paths, types, exclusions) {
+	/** @type {string[]} */
+	const warnings = [];
+
+	if (resolved.options.types) {
+		validate_types(warnings, types, resolved.options.types);
+	}
+
+	if (resolved.options.paths) {
+		validate_paths(
+			warnings,
+			/** @type {string} */ (resolved.options.pathsBasePath),
+			paths,
+			resolved.options.paths
+		);
+	}
+
+	if (exclusions) {
+		validate_exclusions(warnings, dir, exclusions, resolved.fileNames);
+	}
+
+	for (const key in ESSENTIAL_OPTIONS) {
+		if (resolved.options[key] !== ESSENTIAL_OPTIONS[key]) {
+			warnings.push(
+				`"${key}" was overwritten. It should be ${JSON.stringify(ESSENTIAL_OPTIONS[key])}`
+			);
+		}
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string[]} expected
+ * @param {string[]} actual
+ */
+export function validate_types(warnings, expected, actual) {
+	const missing_types = expected.filter((/** @type {string} */ type) => !actual.includes(type));
+
+	if (missing_types.length > 0) {
+		warnings.push(`"types" was overwritten. It must include ${join(missing_types)}`);
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string} base
+ * @param {Record<string, string[]>} expected
+ * @param {ts.MapLike<string[]>} actual
+ */
+export function validate_paths(warnings, base, expected, actual) {
+	/** @type {Set<string>} */
+	const mismatch = new Set();
+
+	for (const [k, e] of Object.entries(expected)) {
+		const a = actual[k]?.map((/** @type {string} */ x) =>
+			path.resolve(/** @type {string} */ (base), x)
+		);
+
+		if (JSON.stringify(e) !== JSON.stringify(a)) {
+			mismatch.add(remove_trailing_slashstar(k));
+		}
+	}
+
+	if (mismatch.size > 0) {
+		const joined = join([...mismatch]);
+
+		warnings.push(`"paths" was overwritten. Imports from ${joined} may not typecheck`);
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string} dir
+ * @param {string[]} exclusions
+ * @param {string[]} files
+ */
+export function validate_exclusions(warnings, dir, exclusions, files) {
+	const missing_exclusions = exclusions.map(posixify).filter((exclusion) => {
+		return files.some(
+			(f) => f === exclusion || f.startsWith(exclusion + '/') || f.startsWith(exclusion + '.')
+		);
+	});
+
+	if (missing_exclusions.length > 0) {
+		warnings.push(
+			`${join(missing_exclusions.map((file) => posixify(path.relative(dir, file))))} should be added to the "exclude" array`
+		);
+	}
+
+	return warnings;
+}
+
+/**
+ * Validates that a tsconfig contains `"extends": "<id>"`
+ * @param {any} options
+ * @param {string} id
+ */
+export function extends_id(options, id) {
+	const o = options.extends;
+	return Array.isArray(o) ? o.includes(id) : o === id;
+}

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

@@ -1,10 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import MagicString from 'magic-string';
-import { rimraf, walk, resolve_entry } from '../../../utils/filesystem.js';
+import { walk, resolve_entry } from '../../../utils/filesystem.js';
 import { compact } from '../../../utils/array.js';
 import { posixify } from '../../../utils/os.js';
 import { ts } from '../ts.js';
+import { is_page_route } from '../create_manifest_data/index.js';
 const remove_relative_parent_traversals = (/** @type {string} */ path) =>
 	path.replace(/\.\.\//g, '');
 const is_whitespace = (/** @type {string} */ char) => /\s/.test(char);
@@ -48,7 +49,7 @@ export function write_all_types(config, manifest_data, root) {
 		for (const file of walk(types_dir)) {
 			const dir = path.dirname(file);
 			if (!expected_directories.has(dir)) {
-				rimraf(path.join(types_dir, file));
+				fs.rmSync(path.join(types_dir, file), { force: true, recursive: true });
 			}
 		}
 	}
@@ -278,7 +279,9 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 		let all_pages_have_load = true;
 		/** @type {import('types').RouteParam[]} */
 		const layout_params = [];
-		const ids = ['RouteId'];
+		// a layout can live in a directory that has no `+page` of its own, in which case its own id
+		// is never the matched route — a request to a colocated `+server` doesn't execute layouts
+		const ids = is_page_route(route) ? ['RouteId'] : [];
 
 		route.layout.child_pages?.forEach((page) => {
 			const leaf = routes.get(page);
@@ -312,7 +315,7 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 			ids.push('null');
 		}
 
-		declarations.push(`type LayoutRouteId = ${ids.join(' | ')}`);
+		declarations.push(`type LayoutRouteId = ${ids.join(' | ') || 'never'}`);
 
 		declarations.push(
 			'type LayoutParams = RouteParams & ' + generate_params_type(layout_params, outdir, config)

package/src/exports/node/index.js

@@ -137,14 +137,9 @@ export function getRequest({ request, base, bodySizeLimit }) {
 	}
 
 	const controller = new AbortController();
-	// TODO: Whenever Node >=22.17 is the minimum supported version, we can do `if (request.readableAborted) controller.abort()` instead
-	// see https://github.com/nodejs/node/blob/5cf3c3e24c7257a0c6192ed8ef71efec8ddac22b/lib/internal/streams/readable.js#L1443-L1453
-	let errored = false;
-	let end_emitted = false;
-	request.once('error', () => (errored = true));
-	request.once('end', () => (end_emitted = true));
+
 	request.once('close', () => {
-		if ((errored || request.destroyed) && !end_emitted) {
+		if (request.readableAborted) {
 			controller.abort();
 		}
 	});

package/src/exports/public.d.ts

@@ -121,9 +121,15 @@ type UnpackValidationError<T> =
 export interface Builder {
 	/** Print messages to the console. `log.info` and `log.minor` are silent unless Vite's `logLevel` is `info`. */
 	log: Logger;
-	/** Remove `dir` and all its contents. */
+	/**
+	 * Remove `dir` and all its contents.
+	 * @deprecated Use `fs.rmSync(dir, { force: true, recursive: true })` instead
+	 */
 	rimraf: (dir: string) => void;
-	/** Create `dir` and any required parent directories. */
+	/**
+	 * Create `dir` and any required parent directories.
+	 * @deprecated Use `fs.mkdirSync(dir, { recursive: true })` instead
+	 */
 	mkdirp: (dir: string) => void;
 
 	/** The fully resolved SvelteKit config. */
@@ -253,8 +259,9 @@ export interface Builder {
 	/**
 	 * Compress files in `directory` with gzip and brotli, where appropriate. Generates `.gz` and `.br` files alongside the originals.
 	 * @param {string} directory The directory containing the files to be compressed
+	 * @returns an array of the files in `directory` that were compressed
 	 */
-	compress: (directory: string) => Promise<void>;
+	compress: (directory: string) => Promise<string[]>;
 }
 
 /**
@@ -862,7 +869,7 @@ export interface KitConfig {
 		 * A function that allows you to edit the generated `tsconfig.json`. You can mutate the config (recommended) or return a new one.
 		 * This is useful for extending a shared `tsconfig.json` in a monorepo root, for example.
 		 *
-		 * Note that any paths configured here should be relative to the generated config file, which is written to `node_modules/$app/tsconfig/tsconfig.json`.
+		 * Note that any paths configured here should be relative to the generated config file, which is written to `node_modules/$app/tsconfig.json`.
 		 *
 		 * @default (config) => config
 		 * @since 1.3.0
@@ -1613,7 +1620,7 @@ export interface RequestEvent<
 	/**
 	 * Get or set cookies related to the current request
 	 */
-	cookies: Cookies;
+	readonly cookies: Cookies;
 	/**
 	 * `fetch` is equivalent to the [native `fetch` web API](https://developer.mozilla.org/en-US/docs/Web/API/fetch), with a few additional features:
 	 *
@@ -1625,15 +1632,15 @@ export interface RequestEvent<
 	 *
 	 * You can learn more about making credentialed requests with cookies [here](https://svelte.dev/docs/kit/load#Cookies).
 	 */
-	fetch: typeof fetch;
+	readonly fetch: typeof fetch;
 	/**
 	 * The client's IP address, set by the adapter.
 	 */
-	getClientAddress: () => string;
+	readonly getClientAddress: () => string;
 	/**
 	 * Contains custom data that was added to the request within the [`server handle hook`](https://svelte.dev/docs/kit/hooks#handle).
 	 */
-	locals: App.Locals;
+	readonly locals: App.Locals;
 	/**
 	 * The parameters of the current route - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
 	 *
@@ -1642,19 +1649,19 @@ export interface RequestEvent<
 	 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
 	 * to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 	 */
-	params: Params;
+	readonly params: Params;
 	/**
 	 * Additional data made available through the adapter.
 	 */
-	platform: Readonly<App.Platform> | undefined;
+	readonly platform: Readonly<App.Platform> | undefined;
 	/**
 	 * The original request object.
 	 */
-	request: Request;
+	readonly request: Request;
 	/**
 	 * Info about the current route.
 	 */
-	route: {
+	readonly route: {
 		/**
 		 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
 		 *
@@ -1687,7 +1694,7 @@ export interface RequestEvent<
 	 *
 	 * You cannot add a `set-cookie` header with `setHeaders` — use the [`cookies`](https://svelte.dev/docs/kit/@sveltejs-kit#Cookies) API instead.
 	 */
-	setHeaders: (headers: Record<string, string>) => void;
+	readonly setHeaders: (headers: Record<string, string>) => void;
 	/**
 	 * The requested URL.
 	 *
@@ -1696,22 +1703,22 @@ export interface RequestEvent<
 	 * the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it
 	 * to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 	 */
-	url: URL;
+	readonly url: URL;
 	/**
 	 * `true` if the request comes from the client asking for `+page/layout.server.js` data. The `url` property will be stripped of the internal information
 	 * related to the data request in this case. Use this property instead if the distinction is important to you.
 	 */
-	isDataRequest: boolean;
+	readonly isDataRequest: boolean;
 	/**
 	 * `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
 	 */
-	isSubRequest: boolean;
+	readonly isSubRequest: boolean;
 
 	/**
 	 * Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
 	 * @since 2.31.0
 	 */
-	tracing: {
+	readonly tracing: {
 		/** Whether tracing is enabled. */
 		enabled: boolean;
 		/** The root span for the request. This span is named `sveltekit.handle.root`. */
@@ -1724,7 +1731,7 @@ export interface RequestEvent<
 	 * `true` if the request comes from the client via a remote function. The `url` property will be stripped of the internal information
 	 * related to the data request in this case. Use this property instead if the distinction is important to you.
 	 */
-	isRemoteRequest: boolean;
+	readonly isRemoteRequest: boolean;
 }
 
 /**

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

@@ -1,7 +1,6 @@
 /** @import { AssetDependencies, ManifestData, SSRNode, ValidatedKitConfig } from 'types' */
 /** @import { Manifest, Rolldown } from 'vite' */
 import fs from 'node:fs';
-import { mkdirp } from '../../../utils/filesystem.js';
 import {
 	create_function_as_string,
 	filter_fonts,
@@ -36,8 +35,8 @@ export function build_server_nodes(
 	chunks,
 	root
 ) {
-	mkdirp(`${out}/server/nodes`);
-	mkdirp(`${out}/server/stylesheets`);
+	fs.mkdirSync(`${out}/server/nodes`, { recursive: true });
+	fs.mkdirSync(`${out}/server/stylesheets`, { recursive: true });
 
 	/**
 	 * Stylesheet names and their contents which are below the inline threshold