@sveltejs/kit 1.0.0-next.446 → 1.0.0-next.449

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.446",
+  "version": "1.0.0-next.449",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -12,7 +12,7 @@
   "dependencies": {
     "@sveltejs/vite-plugin-svelte": "^1.0.1",
     "cookie": "^0.5.0",
-    "devalue": "^2.0.1",
+    "devalue": "^3.1.2",
     "kleur": "^4.1.4",
     "magic-string": "^0.26.2",
     "mime": "^3.0.0",
@@ -36,7 +36,6 @@
     "rollup": "^2.75.7",
     "svelte": "^3.48.0",
     "svelte-preprocess": "^4.10.6",
-    "tiny-glob": "^0.2.9",
     "typescript": "^4.7.4",
     "uvu": "^0.5.3",
     "vite": "^3.0.9"
@@ -51,9 +50,8 @@
   "files": [
     "src",
     "!src/**/*.spec.js",
-    "!src/packaging/test",
     "!src/core/**/fixtures",
-    "!src/core/sync/create_manifest_data/test",
+    "!src/core/**/test",
     "types",
     "svelte-kit.js"
   ],
@@ -78,7 +76,7 @@
   },
   "types": "types/index.d.ts",
   "engines": {
-    "node": ">=16.9"
+    "node": ">=16.14"
   },
   "scripts": {
     "build": "npm run types",
@@ -88,7 +86,7 @@
     "format": "npm run lint -- --write",
     "test": "npm run test:unit && npm run test:integration",
     "test:integration": "pnpm run -r --workspace-concurrency 1 --filter=\"./test/**\" test",
-    "test:unit": "uvu src \"(spec\\.js|test[\\\\/]index\\.js)\" -i packaging",
+    "test:unit": "uvu src \"(spec\\.js|test[\\\\/]index\\.js)\"",
     "types": "node scripts/extract-types.js",
     "postinstall": "node svelte-kit.js sync"
   }

package/src/{core/constants.js → constants.js}

@@ -3,3 +3,5 @@
 export const SVELTE_KIT_ASSETS = '/_svelte_kit_assets';
 
 export const GENERATED_COMMENT = '// this file is generated — do not edit it\n';
+
+export const DATA_SUFFIX = '/__data.js';

package/src/core/env.js

@@ -1,4 +1,4 @@
-import { GENERATED_COMMENT } from './constants.js';
+import { GENERATED_COMMENT } from '../constants.js';
 import { runtime_base } from './utils.js';
 
 /**

package/src/core/sync/write_ambient.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { get_env } from '../../exports/vite/utils.js';
-import { GENERATED_COMMENT } from '../constants.js';
+import { GENERATED_COMMENT } from '../../constants.js';
 import { create_types } from '../env.js';
 import { write_if_changed } from './utils.js';
 

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

@@ -561,11 +561,11 @@ export function tweak_types(content, names) {
 									);
 								} else {
 									// prevent "type X is imported but not used" (isn't silenced by @ts-nocheck) when svelte-check runs
-									code.append(`;${type};`);
+									code.append(`;null as any as ${type};`);
 								}
 							} else {
 								// prevent "type X is imported but not used" (isn't silenced by @ts-nocheck) when svelte-check runs
-								code.append(`;${type};`);
+								code.append(`;null as any as ${type};`);
 							}
 
 							modified = true;

package/src/exports/vite/dev/index.js

@@ -8,7 +8,7 @@ import { installPolyfills } from '../../../exports/node/polyfills.js';
 import { coalesce_to_error } from '../../../utils/error.js';
 import { posixify } from '../../../utils/filesystem.js';
 import { load_template } from '../../../core/config/index.js';
-import { SVELTE_KIT_ASSETS } from '../../../core/constants.js';
+import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import * as sync from '../../../core/sync/sync.js';
 import { get_mime_lookup, runtime_base, runtime_prefix } from '../../../core/utils.js';
 import { get_env, prevent_illegal_vite_imports, resolve_entry } from '../utils.js';

package/src/exports/vite/preview/index.js

@@ -4,7 +4,7 @@ import sirv from 'sirv';
 import { pathToFileURL } from 'url';
 import { getRequest, setResponse } from '../../../exports/node/index.js';
 import { installPolyfills } from '../../../exports/node/polyfills.js';
-import { SVELTE_KIT_ASSETS } from '../../../core/constants.js';
+import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { loadEnv } from 'vite';
 
 /** @typedef {import('http').IncomingMessage} Req */

package/src/runtime/client/client.js

@@ -10,6 +10,7 @@ import Root from '__GENERATED__/root.svelte';
 import { nodes, server_loads, dictionary, matchers } from '__GENERATED__/client-manifest.js';
 import { HttpError, Redirect } from '../control.js';
 import { stores } from './singletons.js';
+import { DATA_SUFFIX } from '../../constants.js';
 
 const SCROLL_KEY = 'sveltekit:scroll';
 const INDEX_KEY = 'sveltekit:index';
@@ -393,7 +394,7 @@ export function create_client({ target, base, trailing_slash }) {
 	 *   status: number;
 	 *   error: HttpError | Error | null;
 	 *   routeId: string | null;
-	 *   validation_errors?: string | undefined;
+	 *   validation_errors?: Record<string, any> | null;
 	 * }} opts
 	 */
 	async function get_navigation_result_from_branch({
@@ -715,24 +716,14 @@ export function create_client({ target, base, trailing_slash }) {
 
 		if (invalid_server_nodes.some(Boolean)) {
 			try {
-				const res = await native_fetch(
-					`${url.pathname}${url.pathname.endsWith('/') ? '' : '/'}__data.json${url.search}`,
-					{
-						headers: {
-							'x-sveltekit-invalidated': invalid_server_nodes.map((x) => (x ? '1' : '')).join(',')
-						}
-					}
-				);
-
-				server_data = /** @type {import('types').ServerData} */ (await res.json());
-
-				if (!res.ok) {
-					throw server_data;
-				}
-			} catch (e) {
-				// something went catastrophically wrong — bail and defer to the server
-				native_navigation(url);
-				return;
+				server_data = await load_data(url, invalid_server_nodes);
+			} catch (error) {
+				return load_root_error_page({
+					status: 500,
+					error: /** @type {Error} */ (error),
+					url,
+					routeId: route.id
+				});
 			}
 
 			if (server_data.type === 'redirect') {
@@ -882,19 +873,18 @@ export function create_client({ target, base, trailing_slash }) {
 		if (node.server) {
 			// TODO post-https://github.com/sveltejs/kit/discussions/6124 we can use
 			// existing root layout data
-			const res = await native_fetch(
-				`${url.pathname}${url.pathname.endsWith('/') ? '' : '/'}__data.json${url.search}`,
-				{
-					headers: {
-						'x-sveltekit-invalidated': '1'
-					}
-				}
-			);
+			try {
+				const server_data = await load_data(url, [true]);
 
-			const server_data_nodes = await res.json();
-			server_data_node = server_data_nodes?.[0] ?? null;
+				if (
+					server_data.type !== 'data' ||
+					(server_data.nodes[0] && server_data.nodes[0].type !== 'data')
+				) {
+					throw 0;
+				}
 
-			if (!res.ok || server_data_nodes?.type !== 'data') {
+				server_data_node = server_data.nodes[0] ?? null;
+			} catch {
 				// at this point we have no choice but to fall back to the server
 				native_navigation(url);
 
@@ -1298,32 +1288,24 @@ export function create_client({ target, base, trailing_slash }) {
 			});
 		},
 
-		_hydrate: async ({ status, error, node_ids, params, routeId }) => {
+		_hydrate: async ({
+			status,
+			error: original_error, // TODO get rid of this
+			node_ids,
+			params,
+			routeId,
+			data: server_data_nodes,
+			errors: validation_errors
+		}) => {
 			const url = new URL(location.href);
 
 			/** @type {import('./types').NavigationFinished | undefined} */
 			let result;
 
 			try {
-				/**
-				 * @param {string} type
-				 * @param {any} fallback
-				 */
-				const parse = (type, fallback) => {
-					const script = document.querySelector(`script[sveltekit\\:data-type="${type}"]`);
-					return script?.textContent ? JSON.parse(script.textContent) : fallback;
-				};
-				/**
-				 * @type {Array<import('types').ServerDataNode | null>}
-				 * On initial navigation, this will only consist of data nodes or `null`.
-				 * A possible error is passed through the `error` property, in which case
-				 * the last entry of `node_ids` is an error page and the last entry of
-				 * `server_data_nodes` is `null`.
-				 */
-				const server_data_nodes = parse('server_data', []);
-				const validation_errors = parse('validation_errors', undefined);
-
 				const branch_promises = node_ids.map(async (n, i) => {
+					const server_data_node = server_data_nodes[i];
+
 					return load_node({
 						loader: nodes[n],
 						url,
@@ -1336,7 +1318,7 @@ export function create_client({ target, base, trailing_slash }) {
 							}
 							return data;
 						},
-						server_data_node: create_data_node(server_data_nodes[i])
+						server_data_node: create_data_node(server_data_node)
 					});
 				});
 
@@ -1345,13 +1327,15 @@ export function create_client({ target, base, trailing_slash }) {
 					params,
 					branch: await Promise.all(branch_promises),
 					status,
-					error: /** @type {import('../server/page/types').SerializedHttpError} */ (error)
+					error: /** @type {import('../server/page/types').SerializedHttpError} */ (original_error)
 						?.__is_http_error
 						? new HttpError(
-								/** @type {import('../server/page/types').SerializedHttpError} */ (error).status,
-								error.message
+								/** @type {import('../server/page/types').SerializedHttpError} */ (
+									original_error
+								).status,
+								original_error.message
 						  )
-						: error,
+						: original_error,
 					validation_errors,
 					routeId
 				});
@@ -1377,3 +1361,34 @@ export function create_client({ target, base, trailing_slash }) {
 		}
 	};
 }
+
+let data_id = 1;
+
+/**
+ * @param {URL} url
+ * @param {boolean[]} invalid
+ * @returns {Promise<import('types').ServerData>}
+ */
+async function load_data(url, invalid) {
+	const data_url = new URL(url);
+	data_url.pathname = url.pathname.replace(/\/$/, '') + DATA_SUFFIX;
+	data_url.searchParams.set('__invalid', invalid.map((x) => (x ? 'y' : 'n')).join(''));
+	data_url.searchParams.set('__id', String(data_id++));
+
+	// The __data.js file is generated by the server and looks like
+	// `window.__sveltekit_data = ${devalue(data)}`. We do this instead
+	// of `export const data` because modules are cached indefinitely,
+	// and that would cause memory leaks.
+	//
+	// The data is read and deleted in the same tick as the promise
+	// resolves, so it's not vulnerable to race conditions
+	await import(/* @vite-ignore */ data_url.href);
+
+	// @ts-expect-error
+	const server_data = window.__sveltekit_data;
+
+	// @ts-expect-error
+	delete window.__sveltekit_data;
+
+	return server_data;
+}

package/src/runtime/client/start.js

@@ -20,6 +20,8 @@ export { set_public_env } from '../env-public.js';
  *     node_ids: number[];
  *     params: Record<string, string>;
  *     routeId: string | null;
+ *     data: Array<import('types').ServerDataNode | null>;
+ *     errors: Record<string, any> | null;
  *   };
  * }} opts
  */

package/src/runtime/client/types.d.ts

@@ -27,6 +27,8 @@ export interface Client {
 		node_ids: number[];
 		params: Record<string, string>;
 		routeId: string | null;
+		data: Array<import('types').ServerDataNode | null>;
+		errors: Record<string, any> | null;
 	}) => Promise<void>;
 	_start_router: () => void;
 }

package/src/runtime/server/data/index.js

@@ -0,0 +1,146 @@
+import { HttpError, Redirect } from '../../control.js';
+import { normalize_error } from '../../../utils/error.js';
+import { once } from '../../../utils/functions.js';
+import { load_server_data } from '../page/load_data.js';
+import { data_response, error_to_pojo } from '../utils.js';
+import { normalize_path } from '../../../utils/url.js';
+import { DATA_SUFFIX } from '../../../constants.js';
+
+/**
+ * @param {import('types').RequestEvent} event
+ * @param {import('types').SSRRoute} route
+ * @param {import('types').SSROptions} options
+ * @param {import('types').SSRState} state
+ * @returns {Promise<Response>}
+ */
+export async function render_data(event, route, options, state) {
+	if (!route.page) {
+		// requesting /__data.js should fail for a +server.js
+		return new Response(undefined, {
+			status: 404
+		});
+	}
+
+	try {
+		const node_ids = [...route.page.layouts, route.page.leaf];
+
+		const invalidated =
+			event.url.searchParams
+				.get('__invalid')
+				?.split('')
+				.map((x) => x === 'y') ?? node_ids.map(() => true);
+
+		let aborted = false;
+
+		const url = new URL(event.url);
+		url.pathname = normalize_path(
+			url.pathname.slice(0, -DATA_SUFFIX.length),
+			options.trailing_slash
+		);
+
+		url.searchParams.delete('__invalid');
+		url.searchParams.delete('__id');
+
+		const new_event = { ...event, url };
+
+		const functions = node_ids.map((n, i) => {
+			return once(async () => {
+				try {
+					if (aborted) {
+						return /** @type {import('types').ServerDataSkippedNode} */ ({
+							type: 'skip'
+						});
+					}
+
+					// == because it could be undefined (in dev) or null (in build, because of JSON.stringify)
+					const node = n == undefined ? n : await options.manifest._.nodes[n]();
+					return load_server_data({
+						event: new_event,
+						state,
+						node,
+						parent: async () => {
+							/** @type {Record<string, any>} */
+							const data = {};
+							for (let j = 0; j < i; j += 1) {
+								const parent = /** @type {import('types').ServerDataNode | null} */ (
+									await functions[j]()
+								);
+
+								if (parent) {
+									Object.assign(data, parent.data);
+								}
+							}
+							return data;
+						}
+					});
+				} catch (e) {
+					aborted = true;
+					throw e;
+				}
+			});
+		});
+
+		const promises = functions.map(async (fn, i) => {
+			if (!invalidated[i]) {
+				return /** @type {import('types').ServerDataSkippedNode} */ ({
+					type: 'skip'
+				});
+			}
+
+			return fn();
+		});
+
+		let length = promises.length;
+		const nodes = await Promise.all(
+			promises.map((p, i) =>
+				p.catch((e) => {
+					const error = normalize_error(e);
+
+					if (error instanceof Redirect) {
+						throw error;
+					}
+
+					// Math.min because array isn't guaranteed to resolve in order
+					length = Math.min(length, i + 1);
+
+					if (error instanceof HttpError) {
+						return /** @type {import('types').ServerErrorNode} */ ({
+							type: 'error',
+							httperror: { ...error }
+						});
+					}
+
+					options.handle_error(error, event);
+
+					return /** @type {import('types').ServerErrorNode} */ ({
+						type: 'error',
+						error: error_to_pojo(error, options.get_stack)
+					});
+				})
+			)
+		);
+
+		/** @type {import('types').ServerData} */
+		const server_data = {
+			type: 'data',
+			nodes: nodes.slice(0, length)
+		};
+
+		return data_response(server_data);
+	} catch (e) {
+		const error = normalize_error(e);
+
+		if (error instanceof Redirect) {
+			/** @type {import('types').ServerData} */
+			const server_data = {
+				type: 'redirect',
+				location: error.location
+			};
+
+			return data_response(server_data);
+		} else {
+			// TODO make it clearer that this was an unexpected error
+			return data_response(error_to_pojo(error, options.get_stack));
+		}
+	}
+}

package/src/runtime/server/index.js

@@ -2,20 +2,16 @@ import { render_endpoint } from './endpoint.js';
 import { render_page } from './page/index.js';
 import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
-import { coalesce_to_error, normalize_error } from '../../utils/error.js';
-import { serialize_error, GENERIC_ERROR, error_to_pojo } from './utils.js';
+import { coalesce_to_error } from '../../utils/error.js';
+import { serialize_error, GENERIC_ERROR } from './utils.js';
 import { decode_params, disable_search, normalize_path } from '../../utils/url.js';
 import { exec } from '../../utils/routing.js';
 import { negotiate } from '../../utils/http.js';
-import { HttpError, Redirect } from '../control.js';
-import { load_server_data } from './page/load_data.js';
-import { json } from '../../exports/index.js';
-import { once } from '../../utils/functions.js';
+import { render_data } from './data/index.js';
+import { DATA_SUFFIX } from '../../constants.js';
 
 /* global __SVELTEKIT_ADAPTER_NAME__ */
 
-const DATA_SUFFIX = '/__data.json';
-
 /** @param {{ html: string }} opts */
 const default_transform = ({ html }) => html;
 
@@ -69,12 +65,7 @@ export async function respond(request, options, state) {
 	}
 
 	const is_data_request = decoded.endsWith(DATA_SUFFIX);
-
-	if (is_data_request) {
-		const data_suffix_length = DATA_SUFFIX.length - (options.trailing_slash === 'always' ? 1 : 0);
-		decoded = decoded.slice(0, -data_suffix_length) || '/';
-		url = new URL(url.origin + url.pathname.slice(0, -data_suffix_length) + url.search);
-	}
+	if (is_data_request) decoded = decoded.slice(0, -DATA_SUFFIX.length);
 
 	if (!state.prerendering?.fallback) {
 		const matchers = await options.manifest._.matchers();
@@ -92,26 +83,19 @@ export async function respond(request, options, state) {
 		}
 	}
 
-	if (route) {
-		if (route.page) {
-			const normalized = normalize_path(url.pathname, options.trailing_slash);
-
-			if (normalized !== url.pathname && !state.prerendering?.fallback) {
-				return new Response(undefined, {
-					status: 301,
-					headers: {
-						'x-sveltekit-normalize': '1',
-						location:
-							// ensure paths starting with '//' are not treated as protocol-relative
-							(normalized.startsWith('//') ? url.origin + normalized : normalized) +
-							(url.search === '?' ? '' : url.search)
-					}
-				});
-			}
-		} else if (is_data_request) {
-			// requesting /__data.json should fail for a standalone endpoint
+	if (route?.page && !is_data_request) {
+		const normalized = normalize_path(url.pathname, options.trailing_slash);
+
+		if (normalized !== url.pathname && !state.prerendering?.fallback) {
 			return new Response(undefined, {
-				status: 404
+				status: 301,
+				headers: {
+					'x-sveltekit-normalize': '1',
+					location:
+						// ensure paths starting with '//' are not treated as protocol-relative
+						(normalized.startsWith('//') ? url.origin + normalized : normalized) +
+						(url.search === '?' ? '' : url.search)
+				}
 			});
 		}
 	}
@@ -250,116 +234,9 @@ export async function respond(request, options, state) {
 				if (route) {
 					/** @type {Response} */
 					let response;
-					if (is_data_request && route.page) {
-						try {
-							const node_ids = [...route.page.layouts, route.page.leaf];
-
-							const invalidated =
-								request.headers.get('x-sveltekit-invalidated')?.split(',').map(Boolean) ??
-								node_ids.map(() => true);
-
-							let aborted = false;
-
-							const functions = node_ids.map((n, i) => {
-								return once(async () => {
-									try {
-										if (aborted) {
-											return /** @type {import('types').ServerDataSkippedNode} */ ({
-												type: 'skip'
-											});
-										}
-
-										// == because it could be undefined (in dev) or null (in build, because of JSON.stringify)
-										const node = n == undefined ? n : await options.manifest._.nodes[n]();
-										return load_server_data({
-											dev: options.dev,
-											event,
-											state,
-											node,
-											parent: async () => {
-												/** @type {Record<string, any>} */
-												const data = {};
-												for (let j = 0; j < i; j += 1) {
-													const parent = /** @type {import('types').ServerDataNode | null} */ (
-														await functions[j]()
-													);
-
-													if (parent) {
-														Object.assign(data, parent.data);
-													}
-												}
-												return data;
-											}
-										});
-									} catch (e) {
-										aborted = true;
-										throw e;
-									}
-								});
-							});
 
-							const promises = functions.map(async (fn, i) => {
-								if (!invalidated[i]) {
-									return /** @type {import('types').ServerDataSkippedNode} */ ({
-										type: 'skip'
-									});
-								}
-
-								return fn();
-							});
-
-							let length = promises.length;
-							const nodes = await Promise.all(
-								promises.map((p, i) =>
-									p.catch((e) => {
-										const error = normalize_error(e);
-
-										if (error instanceof Redirect) {
-											throw error;
-										}
-
-										// Math.min because array isn't guaranteed to resolve in order
-										length = Math.min(length, i + 1);
-
-										if (error instanceof HttpError) {
-											return /** @type {import('types').ServerErrorNode} */ ({
-												type: 'error',
-												httperror: { ...error }
-											});
-										}
-
-										options.handle_error(error, event);
-
-										return /** @type {import('types').ServerErrorNode} */ ({
-											type: 'error',
-											error: error_to_pojo(error, options.get_stack)
-										});
-									})
-								)
-							);
-
-							/** @type {import('types').ServerData} */
-							const server_data = {
-								type: 'data',
-								nodes: nodes.slice(0, length)
-							};
-
-							response = json(server_data);
-						} catch (e) {
-							const error = normalize_error(e);
-
-							if (error instanceof Redirect) {
-								/** @type {import('types').ServerData} */
-								const server_data = {
-									type: 'redirect',
-									location: error.location
-								};
-
-								response = json(server_data);
-							} else {
-								response = json(error_to_pojo(error, options.get_stack), { status: 500 });
-							}
-						}
+					if (is_data_request) {
+						response = await render_data(event, route, options, state);
 					} else if (route.page) {
 						response = await render_page(event, route, route.page, options, state, resolve_opts);
 					} else if (route.endpoint) {
@@ -371,7 +248,7 @@ export async function respond(request, options, state) {
 					}
 
 					if (!is_data_request) {
-						// we only want to set cookies on __data.json requests, we don't
+						// we only want to set cookies on __data.js requests, we don't
 						// want to cache stuff erroneously etc
 						for (const key in headers) {
 							const value = headers[key];