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

package/src/utils/escape.js

@@ -21,24 +21,12 @@ const escape_html_dict = {
 	'<': '&lt;'
 };
 
-const surrogates = // high surrogate without paired low surrogate
-	'[\\ud800-\\udbff](?![\\udc00-\\udfff])|' +
-	// a valid surrogate pair, the only match with 2 code units
-	// we match it so that we can match unpaired low surrogates in the same pass
-	// TODO: use lookbehind assertions once they are widely supported: (?<![\ud800-udbff])[\udc00-\udfff]
-	'[\\ud800-\\udbff][\\udc00-\\udfff]|' +
-	// unpaired low surrogate (see previous match)
-	'[\\udc00-\\udfff]';
+// `\p{Surrogate}` only matches unpaired surrogates with the `u` flag (a pair is one code point)
+/** @param {Record<string, string>} dict */
+const escape_regex = (dict) => new RegExp(`[${Object.keys(dict).join('')}]|\\p{Surrogate}`, 'gu');
 
-const escape_html_attr_regex = new RegExp(
-	`[${Object.keys(escape_html_attr_dict).join('')}]|` + surrogates,
-	'g'
-);
-
-const escape_html_regex = new RegExp(
-	`[${Object.keys(escape_html_dict).join('')}]|` + surrogates,
-	'g'
-);
+const escape_html_attr_regex = escape_regex(escape_html_attr_dict);
+const escape_html_regex = escape_regex(escape_html_dict);
 
 /**
  * Escapes unpaired surrogates (which are allowed in js strings but invalid in HTML) and
@@ -51,14 +39,10 @@ const escape_html_regex = new RegExp(
  */
 export function escape_html(str, is_attr) {
 	const dict = is_attr ? escape_html_attr_dict : escape_html_dict;
-	const escaped_str = str.replace(is_attr ? escape_html_attr_regex : escape_html_regex, (match) => {
-		if (match.length === 2) {
-			// valid surrogate pair
-			return match;
-		}
-
-		return dict[match] ?? `&#${match.charCodeAt(0)};`;
-	});
+	const escaped_str = str.replace(
+		is_attr ? escape_html_attr_regex : escape_html_regex,
+		(match) => dict[match] ?? `&#${match.charCodeAt(0)};`
+	);
 
 	return escaped_str;
 }

package/src/utils/features.js

@@ -1,6 +1,6 @@
 /**
  * @param {string} route_id
- * @param {any} config
+ * @param {Record<string, any>} config
  * @param {string} feature
  * @param {import('@sveltejs/kit').Adapter | undefined} adapter
  */

package/src/utils/filesystem.js

@@ -2,28 +2,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { posixify } from './os.js';
 
-/** @param {string} dir */
-export function mkdirp(dir) {
-	try {
-		fs.mkdirSync(dir, { recursive: true });
-	} catch (/** @type {any} */ e) {
-		if (e.code === 'EEXIST') {
-			if (!fs.statSync(dir).isDirectory()) {
-				throw new Error(`Cannot create directory ${dir}, a file already exists at this position`, {
-					cause: e
-				});
-			}
-			return;
-		}
-		throw e;
-	}
-}
-
-/** @param {string} path */
-export function rimraf(path) {
-	fs.rmSync(path, { force: true, recursive: true });
-}
-
 /**
  * @param {string} source
  * @param {string} target
@@ -58,7 +36,7 @@ export function copy(source, target, opts = {}) {
 				go(path.join(from, file), path.join(to, file));
 			});
 		} else {
-			mkdirp(path.dirname(to));
+			fs.mkdirSync(path.dirname(to), { recursive: true });
 
 			if (opts.replace) {
 				const data = fs.readFileSync(from, 'utf-8');

package/src/utils/fork.js

@@ -38,7 +38,8 @@ export function forked(module, callback) {
 			const worker = new Worker(fileURLToPath(module), {
 				env: {
 					...process.env,
-					SVELTEKIT_FORK: 'true'
+					SVELTEKIT_FORK: 'true',
+					FORCE_COLOR: '1'
 				}
 			});
 
@@ -60,9 +61,13 @@ export function forked(module, callback) {
 				}
 			);
 
+			worker.once('error', reject);
+
 			worker.on('exit', (code) => {
 				if (code) {
-					reject(new Error(`Failed with code ${code}`));
+					const error = new Error(`Failed with code ${code}`);
+					error.stack = error.message;
+					reject(error);
 				}
 			});
 		});

package/src/utils/hash.js

@@ -20,3 +20,24 @@ export function hash(...values) {
 
 	return (hash >>> 0).toString(36);
 }
+
+/**
+ * Hash of the headers and body a `fetch` was called with. The server-side serializer and the
+ * client-side cache lookup must produce identical values for cached responses to be found.
+ * @param {HeadersInit | undefined} headers
+ * @param {import('types').StrictBody | null | undefined} body
+ */
+export function hash_request(headers, body) {
+	/** @type {import('types').StrictBody[]} */
+	const values = [];
+
+	if (headers) {
+		values.push([...new Headers(headers)].join(','));
+	}
+
+	if (body) {
+		values.push(body);
+	}
+
+	return hash(...values);
+}

package/src/utils/http.js

@@ -11,7 +11,7 @@ export function negotiate(accept, types) {
 	const parts = [];
 
 	accept.split(',').forEach((str, i) => {
-		const match = /([^/ \t]+)\/([^; \t]+)[ \t]*(?:;[ \t]*q=([0-9.]+))?/.exec(str);
+		const match = /^[ \t]*([^/ \t]+)\/([^; \t]+)[ \t]*(?:;[ \t]*q=([0-9.]+))?/.exec(str);
 
 		// no match equals invalid header — ignore
 		if (match) {
@@ -57,12 +57,13 @@ export function negotiate(accept, types) {
 }
 
 /**
- * Returns `true` if the request contains a `content-type` header with the given type
- * @param {Request} request
+ * Returns `true` if a `content-type` header value is one of the given types, ignoring
+ * parameters such as `charset` and comparing case-insensitively
+ * @param {string | null | undefined} header
  * @param  {...string} types
  */
-function is_content_type(request, ...types) {
-	const type = request.headers.get('content-type')?.split(';', 1)[0].trim() ?? '';
+export function matches_content_type(header, ...types) {
+	const type = header?.split(';', 1)[0].trim() ?? '';
 	return types.includes(type.toLowerCase());
 }
 
@@ -72,8 +73,8 @@ function is_content_type(request, ...types) {
 export function is_form_content_type(request) {
 	// These content types must be protected against CSRF
 	// https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement/enctype
-	return is_content_type(
-		request,
+	return matches_content_type(
+		request.headers.get('content-type'),
 		'application/x-www-form-urlencoded',
 		'multipart/form-data',
 		'text/plain',

package/src/utils/import.js

@@ -1,8 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 /**
- * Resolves a peer dependency relative to the current working directory. Duplicated with `packages/adapter-auto`
+ * Resolves a peer dependency relative to the current working directory.
+ *
+ * Mainly used to resolve the correct Vite package when an app's SvelteKit is a
+ * linked local repository.
+ *
+ * Duplicated with `packages/adapter-auto`
  * @param {string} dependency
  * @param {string} root
  */
@@ -46,8 +52,9 @@ function resolve_peer(dependency, root) {
  */
 export async function import_peer(dependency, root) {
 	try {
-		return await import(/* @vite-ignore */ resolve_peer(dependency, root));
+		return await import(/* @vite-ignore */ pathToFileURL(resolve_peer(dependency, root)).href);
 	} catch {
+		// eslint-disable-next-line kit-node-custom/require-path-to-file-url -- bare package specifier, not a path
 		return await import(/* @vite-ignore */ dependency);
 	}
 }

package/src/utils/imports.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Reads the `imports` field from the package.json at the given directory.
+ * @param {string} cwd
+ * @returns {Record<string, string | Record<string, string>> | undefined}
+ */
+export function read_package_imports(cwd) {
+	const pkg_path = path.resolve(cwd, 'package.json');
+	if (fs.existsSync(pkg_path)) {
+		try {
+			return JSON.parse(fs.readFileSync(pkg_path, 'utf-8')).imports;
+		} catch {
+			// malformed package.json — ignore, the user will see other errors
+		}
+	}
+}
+
+/**
+ * Normalizes an import value to a string path, handling both string values
+ * and conditional export objects (using the `default` key).
+ * @param {string | Record<string, string>} value
+ * @returns {string | null}
+ */
+export function normalize_import_value(value) {
+	if (typeof value === 'string') {
+		return value.replace(/^\.\//, '');
+	}
+	if (value && typeof value === 'object' && typeof value.default === 'string') {
+		return value.default.replace(/^\.\//, '');
+	}
+	return null;
+}
+
+/**
+ * Returns the `#`-prefixed import keys from the package.json `imports` field.
+ * @param {string} cwd
+ * @returns {string[]}
+ */
+export function get_hash_import_keys(cwd) {
+	const imports = read_package_imports(cwd);
+	if (!imports) return [];
+	return Object.keys(imports).filter((key) => key.startsWith('#'));
+}
+
+/**
+ * Computes alias entries for `normalize_id` from the package.json `imports` field.
+ * Each entry maps a `#xx` alias to its absolute target path. Entries are sorted
+ * by path length descending so that longer/more-specific paths are matched first.
+ *
+ * @param {string} root
+ * @param {(p: string) => string} [normalize] - optional path normalizer (e.g. `vite.normalizePath`)
+ * @returns {Array<{ alias: string, path: string }>}
+ */
+export function get_import_aliases(root, normalize) {
+	const imports = read_package_imports(root);
+	if (!imports) return [];
+
+	/** @type {Array<{ alias: string, path: string }>} */
+	const aliases = [];
+
+	for (const [key, raw_value] of Object.entries(imports)) {
+		if (!key.startsWith('#')) continue;
+
+		const value = normalize_import_value(raw_value);
+		if (!value) continue;
+
+		// For `#xx/*` imports, the target directory is the value without `/*`
+		// For `#xx` imports, the target is the file itself
+		const target = value.endsWith('/*') ? value.slice(0, -2) : value;
+		if (target.includes('*')) continue; // not sure if this is even allowed in Node, anyway it's too niche/complex to support here
+		const abs = path.resolve(root, target);
+		const alias = key.endsWith('/*') ? key.slice(0, -2) : key;
+
+		aliases.push({ alias, path: normalize ? normalize(abs) : abs });
+	}
+
+	// Sort by path length descending so longer/more-specific paths match first
+	aliases.sort((a, b) => b.path.length - a.path.length);
+
+	return aliases;
+}

package/src/utils/mime.js

@@ -0,0 +1,9 @@
+import { mimes, lookup } from 'mrmime';
+
+// `mrmime` does not include `.ico` in its database. The IANA-registered
+// type is `image/vnd.microsoft.icon`, but `image/x-icon` is the
+// semi-official type that is universally supported by browsers and other
+// tools, so we use that.
+mimes['ico'] = 'image/x-icon';
+
+export { lookup };

package/src/utils/page_nodes.js

@@ -1,3 +1,4 @@
+/** @import { UniversalNode, ServerNode } from 'types' */
 import {
 	validate_layout_exports,
 	validate_layout_server_exports,
@@ -42,10 +43,10 @@ export class PageNodes {
 	/**
 	 * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash'} Option
 	 * @param {Option} option
-	 * @returns {Value | undefined}
+	 * @returns {(UniversalNode | ServerNode)[Option] | undefined}
 	 */
 	#get_option(option) {
-		/** @typedef {(import('types').UniversalNode | import('types').ServerNode)[Option]} Value */
+		/** @typedef {(UniversalNode | ServerNode)[Option]} Value */
 
 		return this.data.reduce((value, node) => {
 			return node?.universal?.[option] ?? node?.server?.[option] ?? value;
@@ -69,7 +70,7 @@ export class PageNodes {
 	}
 
 	get_config() {
-		/** @type {any} */
+		/** @type {Record<string, any>} */
 		let current = {};
 
 		for (const node of this.data) {
@@ -77,13 +78,11 @@ export class PageNodes {
 
 			current = {
 				...current,
-				// TODO: should we override the server config value with the universal value similar to other page options?
-				...node?.universal?.config,
-				...node?.server?.config
+				...node?.server?.config,
+				...node?.universal?.config
 			};
 		}
 
-		// TODO 3.0 always return `current`? then we can get rid of `?? {}` in other places
 		return Object.keys(current).length ? current : undefined;
 	}
 

package/src/utils/params.js

@@ -0,0 +1,67 @@
+/** @import { ParamMatcher } from '@sveltejs/kit/params' */
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+/**
+ * @param {import('types').RouteData[]} routes
+ * @returns {Set<string>}
+ */
+export function collect_matcher_names(routes) {
+	/** @type {Set<string>} */
+	const names = new Set();
+
+	for (const route of routes) {
+		for (const param of route.params) {
+			if (param.matcher) names.add(param.matcher);
+		}
+	}
+
+	return names;
+}
+
+/**
+ * @param {Record<string, unknown>} params
+ * @param {Set<string>} names
+ * @param {string} [file]
+ */
+export function validate_param_matchers(params, names, file) {
+	for (const name of names) {
+		if (!Object.hasOwn(params, name)) {
+			throw new Error(`No matcher found for parameter '${name}'${file ? ` in ${file}` : ''}`);
+		}
+	}
+}
+
+/**
+ * @param {{
+ *   routes: import('types').RouteData[];
+ *   params_path: string | null;
+ *   root: string;
+ *   load?: (file: string) => Promise<Record<string, unknown>>;
+ * }} opts
+ * @returns {Promise<Record<string, ParamMatcher> | null>}
+ */
+export async function load_and_validate_params({ routes, params_path, root, load }) {
+	const names = collect_matcher_names(routes);
+
+	if (names.size === 0) return null;
+
+	if (!params_path) {
+		throw new Error(`No matcher found for parameter '${names.values().next().value}'`);
+	}
+
+	const file = path.resolve(root, params_path);
+	const module = load ? await load(file) : await import(pathToFileURL(file).href);
+
+	if (!module.params || typeof module.params !== 'object') {
+		throw new Error(`${params_path} does not export \`params\` from \`defineParams\``);
+	}
+
+	validate_param_matchers(
+		/** @type {Record<string, unknown>} */ (module.params),
+		names,
+		params_path
+	);
+
+	return /** @type {Record<string, ParamMatcher>} */ (module.params);
+}

package/src/utils/regex.js

@@ -0,0 +1,9 @@
+/**
+ * Escapes characters that have special meaning in a regular expression.
+ * @param {string} str
+ * @returns {string} escaped string
+ */
+export function escape_for_regexp(str) {
+	// TODO replace with `RegExp.escape(str)` when we require Node >= 24
+	return str.replace(/[.*+?^${}()|[\]\\]/g, (match) => '\\' + match);
+}