@sveltejs/kit 1.30.3 → 2.0.1

package/src/core/sync/write_tsconfig.js

@@ -3,7 +3,6 @@ import path from 'node:path';
 import colors from 'kleur';
 import { posixify } from '../../utils/filesystem.js';
 import { write_if_changed } from './utils.js';
-import { ts } from './ts.js';
 
 /**
  * @param {string} cwd
@@ -42,51 +41,22 @@ export function write_tsconfig(kit, cwd = process.cwd()) {
 	const out = path.join(kit.outDir, 'tsconfig.json');
 
 	const user_config = load_user_tsconfig(cwd);
-	if (user_config) validate_user_config(kit, cwd, out, user_config);
-
-	// only specify baseUrl if a) the user doesn't specify their own baseUrl
-	// and b) they have non-relative paths. this causes problems with auto-imports,
-	// so we print a suggestion that they use relative paths instead
-	// TODO(v2): never include base URL, and skip the check below
-	let include_base_url = false;
-
-	if (user_config && !user_config.options.compilerOptions?.baseUrl) {
-		const non_relative_paths = new Set();
-		for (const paths of Object.values(user_config?.options.compilerOptions?.paths || {})) {
-			for (const path of paths) {
-				if (!path.startsWith('.')) non_relative_paths.add(path);
-			}
-		}
-
-		if (non_relative_paths.size) {
-			include_base_url = true;
-
-			console.log(colors.bold().yellow('Please replace non-relative compilerOptions.paths:\n'));
+	if (user_config) validate_user_config(cwd, out, user_config);
 
-			for (const path of non_relative_paths) {
-				console.log(`  - "${path}" -> "./${path}"`);
-			}
-
-			console.log(
-				'\nDoing so allows us to omit "baseUrl" — which causes problems with imports — from the generated tsconfig.json. See https://github.com/sveltejs/kit/pull/8437 for more information.'
-			);
-		}
-	}
-
-	write_if_changed(out, JSON.stringify(get_tsconfig(kit, include_base_url), null, '\t'));
+	write_if_changed(out, JSON.stringify(get_tsconfig(kit), null, '\t'));
 }
 
 /**
  * Generates the tsconfig that the user's tsconfig inherits from.
  * @param {import('types').ValidatedKitConfig} kit
- * @param {boolean} include_base_url
  */
-export function get_tsconfig(kit, include_base_url) {
+export function get_tsconfig(kit) {
 	/** @param {string} file */
 	const config_relative = (file) => posixify(path.relative(kit.outDir, file));
 
 	const include = new Set([
 		'ambient.d.ts',
+		'non-ambient.d.ts',
 		'./types/**/$types.d.ts',
 		config_relative('vite.config.js'),
 		config_relative('vite.config.ts')
@@ -110,7 +80,7 @@ export function get_tsconfig(kit, include_base_url) {
 	include.add(config_relative(`${test_folder}/**/*.ts`));
 	include.add(config_relative(`${test_folder}/**/*.svelte`));
 
-	const exclude = [config_relative('node_modules/**'), './[!ambient.d.ts]**'];
+	const exclude = [config_relative('node_modules/**')];
 	if (path.extname(kit.files.serviceWorker)) {
 		exclude.push(config_relative(kit.files.serviceWorker));
 	} else {
@@ -122,30 +92,25 @@ export function get_tsconfig(kit, include_base_url) {
 	const config = {
 		compilerOptions: {
 			// generated options
-			baseUrl: include_base_url ? config_relative('.') : undefined,
-			paths: get_tsconfig_paths(kit, include_base_url),
+			paths: get_tsconfig_paths(kit),
 			rootDirs: [config_relative('.'), './types'],
 
 			// essential options
 			// svelte-preprocess cannot figure out whether you have a value or a type, so tell TypeScript
 			// to enforce using \`import type\` instead of \`import\` for Types.
-			importsNotUsedAsValues: 'error',
+			// Also, TypeScript doesn't know about import usages in the template because it only sees the
+			// script of a Svelte file. Therefore preserve all value imports.
+			verbatimModuleSyntax: true,
 			// Vite compiles modules one at a time
 			isolatedModules: true,
-			// TypeScript doesn't know about import usages in the template because it only sees the
-			// script of a Svelte file. Therefore preserve all value imports. Requires TS 4.5 or higher.
-			preserveValueImports: true,
 
 			// This is required for svelte-package to work as expected
 			// Can be overwritten
 			lib: ['esnext', 'DOM', 'DOM.Iterable'],
-			moduleResolution: 'node', // TODO change to "bundler" in SvelteKit v2
+			moduleResolution: 'bundler',
 			module: 'esnext',
 			noEmit: true, // prevent tsconfig error "overwriting input files" - Vite handles the build and ignores this
-			target: 'esnext',
-
-			// TODO(v2): use the new flag verbatimModuleSyntax instead (requires support by Vite/Esbuild)
-			ignoreDeprecations: ts && Number(ts.version.split('.')[0]) >= 5 ? '5.0' : undefined
+			target: 'esnext'
 		},
 		include: [...include],
 		exclude
@@ -170,47 +135,34 @@ function load_user_tsconfig(cwd) {
 }
 
 /**
- * @param {import('types').ValidatedKitConfig} kit
  * @param {string} cwd
  * @param {string} out
  * @param {{ kind: string, options: any }} config
  */
-function validate_user_config(kit, cwd, out, config) {
+function validate_user_config(cwd, out, config) {
 	// we need to check that the user's tsconfig extends the framework config
 	const extend = config.options.extends;
 	const extends_framework_config =
 		typeof extend === 'string'
 			? path.resolve(cwd, extend) === out
 			: Array.isArray(extend)
-			  ? extend.some((e) => path.resolve(cwd, e) === out)
-			  : false;
+				? extend.some((e) => path.resolve(cwd, e) === out)
+				: false;
 
 	const options = config.options.compilerOptions || {};
 
 	if (extends_framework_config) {
-		const { paths: user_paths } = options;
-
-		if (user_paths && fs.existsSync(kit.files.lib)) {
-			/** @type {string[]} */
-			const lib = user_paths['$lib'] || [];
-			/** @type {string[]} */
-			const lib_ = user_paths['$lib/*'] || [];
-
-			// TODO(v2): check needs to be adjusted when we remove the base path
-			const missing_lib_paths =
-				!lib.some((relative) => path.resolve(cwd, relative) === kit.files.lib) ||
-				!lib_.some((relative) => path.resolve(cwd, relative) === path.join(kit.files.lib, '/*'));
-
-			if (missing_lib_paths) {
-				console.warn(
-					colors
-						.bold()
-						.yellow(`Your compilerOptions.paths in ${config.kind} should include the following:`)
-				);
-				let relative = posixify(path.relative('.', kit.files.lib));
-				if (!relative.startsWith('.')) relative = `./${relative}`;
-				console.warn(`{\n  "$lib":["${relative}"],\n  "$lib/*":["${relative}/*"]\n}`);
-			}
+		const { paths, baseUrl } = options;
+
+		if (baseUrl || paths) {
+			console.warn(
+				colors
+					.bold()
+					.yellow(
+						`You have specified a baseUrl and/or paths in your ${config.kind} which interferes with SvelteKit's auto-generated tsconfig.json. ` +
+							'Remove it to avoid problems with intellisense. For path aliases, use `kit.alias` instead: https://kit.svelte.dev/docs/configuration#alias'
+					)
+			);
 		}
 	} else {
 		let relative = posixify(path.relative('.', out));
@@ -235,9 +187,8 @@ const value_regex = /^(.*?)((\/\*)|(\.\w+))?$/;
  * Related to vite alias creation.
  *
  * @param {import('types').ValidatedKitConfig} config
- * @param {boolean} include_base_url
  */
-function get_tsconfig_paths(config, include_base_url) {
+function get_tsconfig_paths(config) {
 	/** @param {string} file */
 	const config_relative = (file) => posixify(path.relative(config.outDir, file));
 
@@ -256,9 +207,7 @@ function get_tsconfig_paths(config, include_base_url) {
 		const value_match = value_regex.exec(value);
 		if (!value_match) throw new Error(`Invalid alias value: ${value}`);
 
-		const rel_path = (include_base_url ? project_relative : config_relative)(
-			remove_trailing_slashstar(value)
-		);
+		const rel_path = config_relative(remove_trailing_slashstar(value));
 		const slashstar = key_match[2];
 
 		if (slashstar) {

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

@@ -480,7 +480,7 @@ function process_node(node, outdir, is_page, proxies, all_pages_have_load = true
 				const from = proxy.modified
 					? `./proxy${replace_ext_with_js(path.basename(file_path))}`
 					: path_to_original(outdir, file_path);
-				const type = `Kit.AwaitedProperties<Awaited<ReturnType<typeof import('${from}').load>>>`;
+				const type = `Kit.LoadProperties<Awaited<ReturnType<typeof import('${from}').load>>>`;
 				return expand ? `Expand<OptionalUnion<EnsureDefined<${type}>>>` : type;
 			} else {
 				return fallback;

package/src/exports/hooks/sequence.js

@@ -111,7 +111,7 @@ export function sequence(...handlers) {
 								transformPageChunk,
 								filterSerializedResponseHeaders,
 								preload
-						  })
+							})
 						: resolve(event, { transformPageChunk, filterSerializedResponseHeaders, preload });
 				}
 			});

package/src/exports/index.js

@@ -1,51 +1,106 @@
 import { HttpError, Redirect, ActionFailure } from '../runtime/control.js';
 import { BROWSER, DEV } from 'esm-env';
-import { get_route_segments } from '../utils/routing.js';
 
 export { VERSION } from '../version.js';
 
 /**
+ * @template {number} TNumber
+ * @template {any[]} [TArray=[]]
+ * @typedef {TNumber extends TArray['length'] ? TArray[number] : LessThan<TNumber, [...TArray, TArray['length']]>} LessThan
+ */
+
+/**
+ * @template {number} TStart
+ * @template {number} TEnd
+ * @typedef {Exclude<TEnd | LessThan<TEnd>, LessThan<TStart>>} NumericRange
+ */
+
+// we have to repeat the JSDoc because the display for function overloads is broken
+// see https://github.com/microsoft/TypeScript/issues/55056
+
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this will cause SvelteKit to
+ * return an error response without invoking `handleError`.
+ * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @param {NumericRange<400, 599>} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {App.Error} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
  * @overload
- * @param {number} status
+ * @param {NumericRange<400, 599>} status
  * @param {App.Error} body
- * @return {HttpError}
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
  */
-
 /**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this will cause SvelteKit to
+ * return an error response without invoking `handleError`.
+ * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @param {NumericRange<400, 599>} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body] An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
  * @overload
- * @param {number} status
+ * @param {NumericRange<400, 599>} status
  * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body]
- * @return {HttpError}
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
  */
-
 /**
- * Creates an `HttpError` object with an HTTP status code and an optional message.
- * This object, if thrown during request handling, will cause SvelteKit to
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this will cause SvelteKit to
  * return an error response without invoking `handleError`.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
- * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {NumericRange<400, 599>} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
  * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
  */
 export function error(status, body) {
 	if ((!BROWSER || DEV) && (isNaN(status) || status < 400 || status > 599)) {
 		throw new Error(`HTTP error status codes must be between 400 and 599 — ${status} is invalid`);
 	}
 
-	return new HttpError(status, body);
+	throw new HttpError(status, body);
 }
 
 /**
- * Create a `Redirect` object. If thrown during request handling, SvelteKit will return a redirect response.
+ * Checks whether this is an error thrown by {@link error}.
+ * @template {number} T
+ * @param {unknown} e
+ * @param {T} [status] The status to filter for.
+ * @return {e is (HttpError & { status: T extends undefined ? never : T })}
+ */
+export function isHttpError(e, status) {
+	if (!(e instanceof HttpError)) return false;
+	return !status || e.status === status;
+}
+
+/**
+ * Redirect a request. When called during request handling, SvelteKit will return a redirect response.
  * Make sure you're not catching the thrown redirect, which would prevent SvelteKit from handling it.
- * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.
+ * @param {NumericRange<300, 308>} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.
  * @param {string | URL} location The location to redirect to.
+ * @throws {Redirect} This error instructs SvelteKit to redirect to the specified location.
+ * @throws {Error} If the provided status is invalid.
+ * @return {never}
  */
 export function redirect(status, location) {
 	if ((!BROWSER || DEV) && (isNaN(status) || status < 300 || status > 308)) {
 		throw new Error('Invalid status code');
 	}
 
-	return new Redirect(status, location.toString());
+	throw new Redirect(status, location.toString());
+}
+
+/**
+ * Checks whether this is a redirect thrown by {@link redirect}.
+ * @param {unknown} e The object to check.
+ * @return {e is Redirect}
+ */
+export function isRedirect(e) {
+	return e instanceof Redirect;
 }
 
 /**
@@ -100,68 +155,30 @@ export function text(body, init) {
 	});
 }
 
+/**
+ * Create an `ActionFailure` object.
+ * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @overload
+ * @param {number} status
+ * @returns {import('./public.js').ActionFailure<undefined>}
+ */
 /**
  * Create an `ActionFailure` object.
  * @template {Record<string, unknown> | undefined} [T=undefined]
  * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
- * @param {T} [data] Data associated with the failure (e.g. validation errors)
- * @returns {ActionFailure<T>}
+ * @param {T} data Data associated with the failure (e.g. validation errors)
+ * @overload
+ * @param {number} status
+ * @param {T} data
+ * @returns {import('./public.js').ActionFailure<T>}
  */
-export function fail(status, data) {
-	return new ActionFailure(status, data);
-}
-
-const basic_param_pattern = /\[(\[)?(\.\.\.)?(\w+?)(?:=(\w+))?\]\]?/g;
-
-let warned = false;
-
 /**
- * @deprecated Use `resolveRoute` from `$app/paths` instead.
- *
- * Populate a route ID with params to resolve a pathname.
- * @example
- * ```js
- * resolvePath(
- *   `/blog/[slug]/[...somethingElse]`,
- *   {
- *     slug: 'hello-world',
- *     somethingElse: 'something/else'
- *   }
- * ); // `/blog/hello-world/something/else`
- * ```
- * @param {string} id
- * @param {Record<string, string | undefined>} params
- * @returns {string}
+ * Create an `ActionFailure` object.
+ * @param {number} status
+ * @param {any} [data]
+ * @returns {import('./public.js').ActionFailure<any>}
  */
-export function resolvePath(id, params) {
-	if (!warned) {
-		console.warn('`resolvePath` is deprecated. Use `resolveRoute` from `$app/paths` instead.');
-		warned = true;
-	}
-
-	const segments = get_route_segments(id);
-	return (
-		'/' +
-		segments
-			.map((segment) =>
-				segment.replace(basic_param_pattern, (_, optional, rest, name) => {
-					const param_value = params[name];
-
-					// This is nested so TS correctly narrows the type
-					if (!param_value) {
-						if (optional) return '';
-						if (rest && param_value !== undefined) return '';
-						throw new Error(`Missing parameter '${name}' in route ${id}`);
-					}
-
-					if (param_value.startsWith('/') || param_value.endsWith('/'))
-						throw new Error(
-							`Parameter '${name}' in route ${id} cannot start or end with a slash -- this would cause an invalid route like foo//bar`
-						);
-					return param_value;
-				})
-			)
-			.filter(Boolean)
-			.join('/')
-	);
+export function fail(status, data) {
+	// @ts-expect-error unique symbol missing
+	return new ActionFailure(status, data);
 }

package/src/exports/node/index.js

@@ -1,5 +1,5 @@
 import * as set_cookie_parser from 'set-cookie-parser';
-import { error } from '../index.js';
+import { SvelteKitError } from '../../runtime/control.js';
 
 /**
  * @param {import('http').IncomingMessage} req
@@ -22,19 +22,6 @@ function get_raw_body(req, body_size_limit) {
 		return null;
 	}
 
-	let length = content_length;
-
-	if (body_size_limit) {
-		if (!length) {
-			length = body_size_limit;
-		} else if (length > body_size_limit) {
-			throw error(
-				413,
-				`Received content-length of ${length}, but only accept up to ${body_size_limit} bytes.`
-			);
-		}
-	}
-
 	if (req.destroyed) {
 		const readable = new ReadableStream();
 		readable.cancel();
@@ -46,6 +33,17 @@ function get_raw_body(req, body_size_limit) {
 
 	return new ReadableStream({
 		start(controller) {
+			if (body_size_limit !== undefined && content_length > body_size_limit) {
+				const error = new SvelteKitError(
+					413,
+					'Payload Too Large',
+					`Content-length of ${content_length} exceeds limit of ${body_size_limit} bytes.`
+				);
+
+				controller.error(error);
+				return;
+			}
+
 			req.on('error', (error) => {
 				cancelled = true;
 				controller.error(error);
@@ -60,16 +58,15 @@ function get_raw_body(req, body_size_limit) {
 				if (cancelled) return;
 
 				size += chunk.length;
-				if (size > length) {
+				if (size > content_length) {
 					cancelled = true;
-					controller.error(
-						error(
-							413,
-							`request body size exceeded ${
-								content_length ? "'content-length'" : 'BODY_SIZE_LIMIT'
-							} of ${length}`
-						)
-					);
+
+					const constraint = content_length ? 'content-length' : 'BODY_SIZE_LIMIT';
+					const message = `request body size exceeded ${constraint} of ${content_length}`;
+
+					const error = new SvelteKitError(413, 'Payload Too Large', message);
+					controller.error(error);
+
 					return;
 				}
 
@@ -124,7 +121,7 @@ export async function setResponse(res, response) {
 					? set_cookie_parser.splitCookiesString(
 							// This is absurd but necessary, TODO: investigate why
 							/** @type {string}*/ (response.headers.get(key))
-					  )
+						)
 					: value
 			);
 		} catch (error) {

package/src/exports/node/polyfills.js

@@ -1,54 +1,25 @@
-import { ReadableStream, TransformStream, WritableStream } from 'node:stream/web';
 import buffer from 'node:buffer';
 import { webcrypto as crypto } from 'node:crypto';
-import { fetch, Response, Request, Headers, FormData, File as UndiciFile } from 'undici';
 
 // `buffer.File` was added in Node 18.13.0 while the `File` global was added in Node 20.0.0
-const File = /** @type {import('node:buffer') & { File?: File}} */ (buffer).File ?? UndiciFile;
+const File = /** @type {import('node:buffer') & { File?: File}} */ (buffer).File;
 
 /** @type {Record<string, any>} */
-const globals_post_node_18_11 = {
+const globals = {
 	crypto,
 	File
 };
 
-/** @type {Record<string, any>} */
-// TODO: remove this once we only support Node 18.11+ (the version multipart/form-data was added)
-const globals_pre_node_18_11 = {
-	crypto,
-	fetch,
-	Response,
-	Request,
-	Headers,
-	ReadableStream,
-	TransformStream,
-	WritableStream,
-	FormData,
-	File
-};
-
 // exported for dev/preview and node environments
 /**
  * Make various web APIs available as globals:
  * - `crypto`
- * - `fetch` (only in node < 18.11)
- * - `Headers` (only in node < 18.11)
- * - `Request` (only in node < 18.11)
- * - `Response` (only in node < 18.11)
+ * - `File`
  */
 export function installPolyfills() {
-	// Be defensive (we don't know in which environments this is called) and always apply if something goes wrong
-	let globals = globals_pre_node_18_11;
-	try {
-		const version = process.versions.node.split('.').map((n) => parseInt(n, 10));
-		if ((version[0] === 18 && version[1] >= 11) || version[0] > 18) {
-			globals = globals_post_node_18_11;
-		}
-	} catch (e) {
-		// ignore
-	}
-
 	for (const name in globals) {
+		if (name in globalThis) continue;
+
 		Object.defineProperty(globalThis, name, {
 			enumerable: true,
 			configurable: true,