@sveltejs/kit 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/src/core/postbuild/analyse.js

@@ -106,8 +106,8 @@ async function analyse({ manifest_path, env }) {
 
 			for (const layout of layouts) {
 				if (layout) {
-					validate_common_exports(layout.server, route.id);
-					validate_common_exports(layout.universal, route.id);
+					validate_common_exports(layout.server, layout.server_id);
+					validate_common_exports(layout.universal, layout.universal_id);
 				}
 			}
 
@@ -115,8 +115,8 @@ async function analyse({ manifest_path, env }) {
 				methods.add('GET');
 				if (page.server?.actions) methods.add('POST');
 
-				validate_page_server_exports(page.server, route.id);
-				validate_common_exports(page.universal, route.id);
+				validate_page_server_exports(page.server, page.server_id);
+				validate_common_exports(page.universal, page.universal_id);
 			}
 
 			const should_prerender = get_option(nodes, 'prerender');

package/src/core/postbuild/prerender.js

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { installPolyfills } from '../../exports/node/polyfills.js';
 import { mkdirp, posixify, walk } from '../../utils/filesystem.js';
 import { should_polyfill } from '../../utils/platform.js';
-import { is_root_relative, resolve } from '../../utils/url.js';
+import { decode_uri, is_root_relative, resolve } from '../../utils/url.js';
 import { escape_html_attr } from '../../utils/escape.js';
 import { logger } from '../utils.js';
 import { load_config } from '../config/index.js';
@@ -207,7 +207,7 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 			// this seems circuitous, but using new URL allows us to not care
 			// whether dependency_path is encoded or not
 			const encoded_dependency_path = new URL(dependency_path, 'http://localhost').pathname;
-			const decoded_dependency_path = decodeURI(encoded_dependency_path);
+			const decoded_dependency_path = decode_uri(encoded_dependency_path);
 
 			const headers = Object.fromEntries(result.response.headers);
 
@@ -215,7 +215,7 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 			if (prerender) {
 				const encoded_route_id = headers['x-sveltekit-routeid'];
 				if (encoded_route_id != null) {
-					const route_id = decodeURI(encoded_route_id);
+					const route_id = decode_uri(encoded_route_id);
 					const existing_value = prerender_map.get(route_id);
 					if (existing_value !== 'auto') {
 						prerender_map.set(route_id, prerender === 'true' ? true : 'auto');
@@ -257,7 +257,7 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 				}
 
 				if (hash) {
-					const key = decodeURI(pathname + hash);
+					const key = decode_uri(pathname + hash);
 
 					if (!expected_hashlinks.has(key)) {
 						expected_hashlinks.set(key, new Set());
@@ -266,7 +266,7 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 					/** @type {Set<string>} */ (expected_hashlinks.get(key)).add(decoded);
 				}
 
-				enqueue(decoded, decodeURI(pathname), pathname);
+				enqueue(decoded, decode_uri(pathname), pathname);
 			}
 		}
 	}
@@ -293,7 +293,7 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 		if (written.has(file)) return;
 
 		const encoded_route_id = response.headers.get('x-sveltekit-routeid');
-		const route_id = encoded_route_id != null ? decodeURI(encoded_route_id) : null;
+		const route_id = encoded_route_id != null ? decode_uri(encoded_route_id) : null;
 		if (route_id !== null) prerendered_routes.add(route_id);
 
 		if (response_type === REDIRECT) {
@@ -302,7 +302,7 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 			if (location) {
 				const resolved = resolve(encoded, location);
 				if (is_root_relative(resolved)) {
-					enqueue(decoded, decodeURI(resolved), resolved);
+					enqueue(decoded, decode_uri(resolved), resolved);
 				}
 
 				if (!headers['x-sveltekit-normalize']) {

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

@@ -73,11 +73,13 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 
 			imports.push(`import * as universal from '../${server_manifest[node.universal].file}';`);
 			exports.push(`export { universal };`);
+			exports.push(`export const universal_id = ${s(node.universal)};`);
 		}
 
 		if (node.server) {
 			imports.push(`import * as server from '../${server_manifest[node.server].file}';`);
 			exports.push(`export { server };`);
+			exports.push(`export const server_id = ${s(node.server)};`);
 		}
 
 		exports.push(

package/src/utils/exports.js

@@ -6,36 +6,52 @@ function validator(expected) {
 
 	/**
 	 * @param {any} module
-	 * @param {string} [route_id]
+	 * @param {string} [file]
 	 */
-	function validate(module, route_id) {
+	function validate(module, file) {
 		if (!module) return;
 
 		for (const key in module) {
-			if (key[0] !== '_' && !set.has(key)) {
-				const valid = expected.join(', ');
-				throw new Error(
-					`Invalid export '${key}'${
-						route_id ? ` in ${route_id}` : ''
-					} (valid exports are ${valid}, or anything with a '_' prefix)`
-				);
-			}
+			if (key[0] === '_' || set.has(key)) continue; // key is valid in this module
+
+			const hint =
+				hint_for_supported_files(key, file?.slice(file.lastIndexOf('.'))) ??
+				`valid exports are ${expected.join(', ')}, or anything with a '_' prefix`;
+
+			throw new Error(`Invalid export '${key}'${file ? ` in ${file}` : ''} (${hint})`);
 		}
 	}
 
 	return validate;
 }
 
-export const validate_common_exports = validator([
-	'load',
-	'prerender',
-	'csr',
-	'ssr',
-	'trailingSlash',
-	'config'
-]);
+/**
+ * @param {string} key
+ * @param {string} ext
+ * @returns {string | void}
+ */
+function hint_for_supported_files(key, ext = '.js') {
+	let supported_files = [];
 
-export const validate_page_server_exports = validator([
+	if (valid_common_exports.includes(key)) {
+		supported_files.push(`+page${ext}`);
+	}
+
+	if (valid_page_server_exports.includes(key)) {
+		supported_files.push(`+page.server${ext}`);
+	}
+
+	if (valid_server_exports.includes(key)) {
+		supported_files.push(`+server${ext}`);
+	}
+
+	if (supported_files.length > 0) {
+		return `'${key}' is a valid export in ${supported_files.join(` or `)}`;
+	}
+}
+
+const valid_common_exports = ['load', 'prerender', 'csr', 'ssr', 'trailingSlash', 'config'];
+const valid_page_server_exports = [
 	'load',
 	'prerender',
 	'csr',
@@ -43,9 +59,8 @@ export const validate_page_server_exports = validator([
 	'actions',
 	'trailingSlash',
 	'config'
-]);
-
-export const validate_server_exports = validator([
+];
+const valid_server_exports = [
 	'GET',
 	'POST',
 	'PATCH',
@@ -55,4 +70,8 @@ export const validate_server_exports = validator([
 	'prerender',
 	'trailingSlash',
 	'config'
-]);
+];
+
+export const validate_common_exports = validator(valid_common_exports);
+export const validate_page_server_exports = validator(valid_page_server_exports);
+export const validate_server_exports = validator(valid_server_exports);

package/src/utils/url.js

@@ -75,6 +75,21 @@ export function decode_params(params) {
 	return params;
 }
 
+/**
+ * The error when a URL is malformed is not very helpful, so we augment it with the URI
+ * @param {string} uri
+ */
+export function decode_uri(uri) {
+	try {
+		return decodeURI(uri);
+	} catch (e) {
+		if (e instanceof Error) {
+			e.message = `Failed to decode URI: ${uri}\n` + e.message;
+		}
+		throw e;
+	}
+}
+
 /**
  * URL properties that could change during the lifetime of the page,
  * which excludes things like `origin`

package/types/internal.d.ts

@@ -293,9 +293,8 @@ export interface SSRNode {
 		config?: any;
 	};
 
-	// store this in dev so we can print serialization errors
-	universal_id?: string;
-	server_id?: string;
+	universal_id: string;
+	server_id: string;
 }
 
 export type SSRNodeLoader = () => Promise<SSRNode>;