@sveltejs/kit 1.0.11 → 1.0.13

package/src/exports/vite/index.js

@@ -12,7 +12,7 @@ import { SVELTE_KIT_ASSETS } from '../../constants.js';
 import { create_static_module, create_dynamic_module } from '../../core/env.js';
 import * as sync from '../../core/sync/sync.js';
 import { create_assets } from '../../core/sync/create_manifest_data/index.js';
-import { runtime_base, runtime_directory, runtime_prefix, logger } from '../../core/utils.js';
+import { runtime_base, runtime_directory, logger } from '../../core/utils.js';
 import { load_config } from '../../core/config/index.js';
 import { generate_manifest } from '../../core/generate_manifest/index.js';
 import { build_server } from './build/build_server.js';
@@ -128,7 +128,6 @@ function kit({ svelte_config }) {
 
 	/**
 	 * @type {{
-	 *   build_dir: string;
 	 *   output_dir: string;
 	 *   client_out_dir: string;
 	 * }}
@@ -147,7 +146,7 @@ function kit({ svelte_config }) {
 
 		manifest_data.nodes.forEach((node) => {
 			if (node.component) {
-				const resolved = path.resolve(cwd, node.component);
+				const resolved = path.resolve(node.component);
 				const relative = decodeURIComponent(
 					path.relative(svelte_config.kit.files.routes, resolved)
 				);
@@ -159,7 +158,7 @@ function kit({ svelte_config }) {
 			}
 
 			if (node.universal) {
-				const resolved = path.resolve(cwd, node.universal);
+				const resolved = path.resolve(node.universal);
 				const relative = decodeURIComponent(
 					path.relative(svelte_config.kit.files.routes, resolved)
 				);
@@ -189,7 +188,7 @@ function kit({ svelte_config }) {
 			fs.readFileSync(`${paths.client_out_dir}/${vite_config.build.manifest}`, 'utf-8')
 		);
 
-		const entry_id = posixify(path.relative(cwd, `${runtime_directory}/client/start.js`));
+		const entry_id = posixify(path.relative('.', `${runtime_directory}/client/start.js`));
 
 		return {
 			assets,
@@ -218,7 +217,6 @@ function kit({ svelte_config }) {
 			is_build = config_env.command === 'build';
 
 			paths = {
-				build_dir: `${svelte_config.kit.outDir}/build`,
 				output_dir: `${svelte_config.kit.outDir}/output`,
 				client_out_dir: `${svelte_config.kit.outDir}/output/client`
 			};
@@ -238,8 +236,8 @@ function kit({ svelte_config }) {
 				svelte_config.kit.files.lib,
 				svelte_config.kit.files.routes,
 				svelte_config.kit.outDir,
-				path.resolve(cwd, 'src'), // TODO this isn't correct if user changed all his files to sth else than src (like in test/options)
-				path.resolve(cwd, 'node_modules'),
+				path.resolve('src'), // TODO this isn't correct if user changed all his files to sth else than src (like in test/options)
+				path.resolve('node_modules'),
 				path.resolve(vite.searchForWorkspaceRoot(cwd), 'node_modules')
 			]);
 			// We can only add directories to the allow list, so we find out
@@ -254,6 +252,7 @@ function kit({ svelte_config }) {
 			const result = {
 				define: {
 					__SVELTEKIT_APP_VERSION_POLL_INTERVAL__: '0',
+					__SVELTEKIT_DEV__: config_env.command === 'serve',
 					__SVELTEKIT_EMBEDDED__: svelte_config.kit.embedded ? 'true' : 'false'
 				},
 				resolve: {
@@ -276,7 +275,7 @@ function kit({ svelte_config }) {
 					// a linked dependency, and that causes modules to be imported twice
 					// under different IDs, which breaks a bunch of stuff
 					// https://github.com/vitejs/vite/pull/9296
-					external: ['@sveltejs/kit']
+					external: ['@sveltejs/kit', 'cookie', 'set-cookie-parser']
 				},
 				optimizeDeps: {
 					exclude: [
@@ -307,7 +306,7 @@ function kit({ svelte_config }) {
 				if (
 					is_illegal(id, {
 						cwd: normalized_cwd,
-						node_modules: vite.normalizePath(path.join(cwd, 'node_modules')),
+						node_modules: vite.normalizePath(path.resolve('node_modules')),
 						server: vite.normalizePath(path.join(normalized_lib, 'server'))
 					})
 				) {
@@ -358,10 +357,8 @@ function kit({ svelte_config }) {
 
 			if (is_build) {
 				if (!vite_config.build.watch) {
-					rimraf(paths.build_dir);
 					rimraf(paths.output_dir);
 				}
-				mkdirp(paths.build_dir);
 				mkdirp(paths.output_dir);
 			}
 		},
@@ -380,18 +377,18 @@ function kit({ svelte_config }) {
 		 * @see https://vitejs.dev/guide/api-plugin.html#configureserver
 		 */
 		async configureServer(vite) {
-			// set `import { version } from '$app/environment'`
-			(await vite.ssrLoadModule(`${runtime_prefix}/env.js`)).set_version(
-				svelte_config.kit.version.name
-			);
+			const { set_paths, set_version } = await vite.ssrLoadModule(`${runtime_base}/shared.js`);
 
 			// set `import { base, assets } from '$app/paths'`
 			const { base, assets } = svelte_config.kit.paths;
 
-			(await vite.ssrLoadModule(`${runtime_base}/paths.js`)).set_paths({
+			set_paths({
 				base,
 				assets: assets ? SVELTE_KIT_ASSETS : base
 			});
+
+			// set `import { version } from '$app/environment'`
+			set_version(svelte_config.kit.version.name);
 		}
 	};
 
@@ -489,18 +486,17 @@ function kit({ svelte_config }) {
 				log.info('Building server');
 
 				const options = {
-					cwd,
 					config: svelte_config,
 					vite_config,
 					vite_config_env,
-					build_dir: paths.build_dir, // TODO just pass `paths`
 					manifest_data,
-					output_dir: paths.output_dir,
-					service_worker_entry_file: resolve_entry(svelte_config.kit.files.serviceWorker)
+					output_dir: paths.output_dir
 				};
 				const client = client_build_info(assets, chunks);
 				const server = await build_server(options, client);
 
+				const service_worker_entry_file = resolve_entry(svelte_config.kit.files.serviceWorker);
+
 				/** @type {import('types').BuildData} */
 				build_data = {
 					app_dir: svelte_config.kit.appDir,
@@ -508,7 +504,7 @@ function kit({ svelte_config }) {
 						svelte_config.kit.paths.base ? '/' : ''
 					}${svelte_config.kit.appDir}`,
 					manifest_data,
-					service_worker: options.service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
+					service_worker: !!service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
 					client,
 					server
 				};
@@ -528,9 +524,7 @@ function kit({ svelte_config }) {
 					const results_path = `${svelte_config.kit.outDir}/generated/prerendered.json`;
 
 					// do prerendering in a subprocess so any dangling stuff gets killed upon completion
-					const script = fileURLToPath(
-						new URL('../../core/prerender/prerender.js', import.meta.url)
-					);
+					const script = fileURLToPath(new URL('../../core/postbuild/index.js', import.meta.url));
 
 					const child = fork(
 						script,
@@ -575,14 +569,19 @@ function kit({ svelte_config }) {
 					})};\n`
 				);
 
-				if (options.service_worker_entry_file) {
+				if (service_worker_entry_file) {
 					if (svelte_config.kit.paths.assets) {
 						throw new Error('Cannot use service worker alongside config.kit.paths.assets');
 					}
 
 					log.info('Building service worker');
 
-					await build_service_worker(options, prerendered, client.vite_manifest);
+					await build_service_worker(
+						options,
+						service_worker_entry_file,
+						prerendered,
+						client.vite_manifest
+					);
 				}
 
 				console.log(

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

@@ -34,19 +34,17 @@ export async function preview(vite, vite_config, svelte_config) {
 
 	const etag = `"${Date.now()}"`;
 
-	const index_file = join(svelte_config.kit.outDir, 'output/server/index.js');
-	const manifest_file = join(svelte_config.kit.outDir, 'output/server/manifest.js');
+	const dir = join(svelte_config.kit.outDir, 'output/server');
+
+	/** @type {import('types').ServerInternalModule} */
+	const { set_paths } = await import(pathToFileURL(join(dir, 'internal.js')).href);
 
 	/** @type {import('types').ServerModule} */
-	const { Server, override } = await import(pathToFileURL(index_file).href);
-	const { manifest } = await import(pathToFileURL(manifest_file).href);
-
-	override({
-		paths: { base, assets },
-		building: false,
-		protocol,
-		read: (file) => fs.readFileSync(join(svelte_config.kit.files.assets, file))
-	});
+	const { Server } = await import(pathToFileURL(join(dir, 'index.js')).href);
+
+	const { manifest } = await import(pathToFileURL(join(dir, 'manifest.js')).href);
+
+	set_paths({ base, assets });
 
 	const server = new Server(manifest);
 	await server.init({
@@ -150,7 +148,8 @@ export async function preview(vite, vite_config, svelte_config) {
 						const { remoteAddress } = req.socket;
 						if (remoteAddress) return remoteAddress;
 						throw new Error('Could not determine clientAddress');
-					}
+					},
+					read: (file) => fs.readFileSync(join(svelte_config.kit.files.assets, file))
 				})
 			);
 		});

package/src/runtime/app/environment.js

@@ -10,4 +10,4 @@ export const browser = BROWSER;
  */
 export const dev = DEV;
 
-export { building, version } from '../env.js';
+export { building, version } from '../shared.js';

package/src/runtime/app/paths.js

@@ -1 +1 @@
-export { base, assets } from '../paths.js';
+export { base, assets } from '../shared.js';

package/src/runtime/client/client.js

@@ -467,7 +467,7 @@ export function create_client({ target, base }) {
 			!current.url ||
 			url.href !== current.url.href ||
 			current.error !== error ||
-			form !== undefined ||
+			(form !== undefined && form !== page.form) ||
 			data_changed;
 
 		if (page_changed) {
@@ -824,6 +824,12 @@ export function create_client({ target, base }) {
 						status = err.status;
 						error = err.body;
 					} else {
+						// Referenced node could have been removed due to redeploy, check
+						const updated = await stores.updated.check();
+						if (updated) {
+							return await native_navigation(url);
+						}
+
 						error = await handle_error(err, { params, url, route: { id: route.id } });
 					}
 
@@ -909,7 +915,7 @@ export function create_client({ target, base }) {
 		/** @type {import('types').ServerDataNode | null} */
 		let server_data_node = null;
 
-		if (node.server) {
+		if (node.has_server_load) {
 			// TODO post-https://github.com/sveltejs/kit/discussions/6124 we can use
 			// existing root layout data
 			try {

package/src/runtime/client/fetcher.js

@@ -24,12 +24,20 @@ if (DEV) {
 	check_stack_trace();
 
 	window.fetch = (input, init) => {
+		// Check if fetch was called via load_node. the lock method only checks if it was called at the
+		// same time, but not necessarily if it was called from `load`.
+		// We use just the filename as the method name sometimes does not appear on the CI.
 		const url = input instanceof Request ? input.url : input.toString();
-		const stack = /** @type {string} */ (new Error().stack);
+		const stack_array = /** @type {string} */ (new Error().stack).split('\n');
+		// We need to do some Firefox-specific cutoff because it (impressively) maintains the stack
+		// across events and for example traces a `fetch` call triggered from a button back
+		// to the creation of the event listener and the element creation itself,
+		// where at some point client.js will show up, leading to false positives.
+		const firefox_cutoff = stack_array.findIndex((a) => a.includes('*listen@'));
+		const stack = stack_array
+			.slice(0, firefox_cutoff !== -1 ? firefox_cutoff : undefined)
+			.join('\n');
 
-		// check if fetch was called via load_node. the lock method only checks if it was called at the
-		// same time, but not necessarily if it was called from `load`
-		// we use just the filename as the method name sometimes does not appear on the CI
 		const heuristic = can_inspect_stack_trace
 			? stack.includes('src/runtime/client/client.js')
 			: loading;

package/src/runtime/client/start.js

@@ -1,9 +1,8 @@
 import { DEV } from 'esm-env';
 import { create_client } from './client.js';
 import { init } from './singletons.js';
-import { set_paths } from '../paths.js';
+import { set_paths, set_version } from '../shared.js';
 import { set_public_env } from '../env-public.js';
-import { set_version } from '../env.js';
 
 /**
  * @param {{

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

@@ -26,7 +26,7 @@ export interface Client {
 	// private API
 	_hydrate(opts: {
 		status: number;
-		error: App.Error;
+		error: App.Error | null;
 		node_ids: number[];
 		params: Record<string, string>;
 		route: { id: string | null };

package/src/runtime/client/utils.js

@@ -1,7 +1,6 @@
 import { BROWSER, DEV } from 'esm-env';
 import { writable } from 'svelte/store';
-import { assets } from '../paths.js';
-import { version } from '../env.js';
+import { assets, version } from '../shared.js';
 import { PRELOAD_PRIORITIES } from './constants.js';
 
 /* global __SVELTEKIT_APP_VERSION_FILE__, __SVELTEKIT_APP_VERSION_POLL_INTERVAL__ */

package/src/runtime/control.js

@@ -1,4 +1,4 @@
-export class HttpError {
+export let HttpError = class HttpError {
 	/**
 	 * @param {number} status
 	 * @param {{message: string} extends App.Error ? (App.Error | string | undefined) : App.Error} body
@@ -17,9 +17,9 @@ export class HttpError {
 	toString() {
 		return JSON.stringify(this.body);
 	}
-}
+};
 
-export class Redirect {
+export let Redirect = class Redirect {
 	/**
 	 * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status
 	 * @param {string} location
@@ -28,12 +28,12 @@ export class Redirect {
 		this.status = status;
 		this.location = location;
 	}
-}
+};
 
 /**
  * @template {Record<string, unknown> | undefined} [T=undefined]
  */
-export class ActionFailure {
+export let ActionFailure = class ActionFailure {
 	/**
 	 * @param {number} status
 	 * @param {T} [data]
@@ -42,4 +42,22 @@ export class ActionFailure {
 		this.status = status;
 		this.data = data;
 	}
+};
+
+/**
+ * This is a grotesque hack that, in dev, allows us to replace the implementations
+ * of these classes that you'd get by importing them from `@sveltejs/kit` with the
+ * ones that are imported via Vite and loaded internally, so that instanceof
+ * checks work even though SvelteKit imports this module via Vite and consumers
+ * import it via Node
+ * @param {{
+ *   ActionFailure: typeof ActionFailure;
+ *   HttpError: typeof HttpError;
+ *   Redirect: typeof Redirect;
+ * }} implementations
+ */
+export function replace_implementations(implementations) {
+	ActionFailure = implementations.ActionFailure;
+	HttpError = implementations.HttpError;
+	Redirect = implementations.Redirect;
 }

package/src/runtime/server/ambient.d.ts

@@ -0,0 +1,8 @@
+declare module '__GENERATED__/server-internal.js' {
+	export const options: import('types').SSROptions;
+	export const get_hooks: () => Promise<{
+		handle?: import('types').Handle;
+		handleError?: import('types').HandleServerError;
+		handleFetch?: import('types').HandleFetch;
+	}>;
+}

package/src/runtime/server/cookie.js

@@ -11,10 +11,9 @@ const cookie_paths = {};
 /**
  * @param {Request} request
  * @param {URL} url
- * @param {boolean} dev
  * @param {import('types').TrailingSlash} trailing_slash
  */
-export function get_cookies(request, url, dev, trailing_slash) {
+export function get_cookies(request, url, trailing_slash) {
 	const header = request.headers.get('cookie') ?? '';
 	const initial_cookies = parse(header, { decode: (value) => value });
 
@@ -22,7 +21,7 @@ export function get_cookies(request, url, dev, trailing_slash) {
 	// Emulate browser-behavior: if the cookie is set at '/foo/bar', its path is '/foo'
 	const default_path = normalized_url.split('/').slice(0, -1).join('/') || '/';
 
-	if (dev) {
+	if (__SVELTEKIT_DEV__) {
 		// TODO this could theoretically be wrong if the cookie was set unencoded?
 		const initial_decoded_cookies = parse(header, { decode: decodeURIComponent });
 		// Remove all cookies that no longer exist according to the request
@@ -77,7 +76,7 @@ export function get_cookies(request, url, dev, trailing_slash) {
 			const req_cookies = parse(header, { decode: decoder });
 			const cookie = req_cookies[name]; // the decoded string or undefined
 
-			if (!dev || cookie) {
+			if (!__SVELTEKIT_DEV__ || cookie) {
 				return cookie;
 			}
 
@@ -111,7 +110,7 @@ export function get_cookies(request, url, dev, trailing_slash) {
 				}
 			};
 
-			if (dev) {
+			if (__SVELTEKIT_DEV__) {
 				cookie_paths[name] = cookie_paths[name] ?? new Set();
 				if (!value) {
 					if (!cookie_paths[name].has(path) && cookie_paths[name].size > 0) {

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

@@ -11,6 +11,7 @@ export const INVALIDATED_PARAM = 'x-sveltekit-invalidated';
  * @param {import('types').RequestEvent} event
  * @param {import('types').SSRRoute} route
  * @param {import('types').SSROptions} options
+ * @param {import('types').SSRManifest} manifest
  * @param {import('types').SSRState} state
  * @param {boolean[] | undefined} invalidated_data_nodes
  * @param {import('types').TrailingSlash} trailing_slash
@@ -20,6 +21,7 @@ export async function render_data(
 	event,
 	route,
 	options,
+	manifest,
 	state,
 	invalidated_data_nodes,
 	trailing_slash
@@ -31,6 +33,8 @@ export async function render_data(
 		});
 	}
 
+	state.initiator = route;
+
 	try {
 		const node_ids = [...route.page.layouts, route.page.leaf];
 		const invalidated = invalidated_data_nodes ?? node_ids.map(() => true);
@@ -52,10 +56,9 @@ export async function render_data(
 					}
 
 					// == 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]();
+					const node = n == undefined ? n : await manifest._.nodes[n]();
 					return load_server_data({
 						event: new_event,
-						options,
 						state,
 						node,
 						parent: async () => {

package/src/runtime/server/endpoint.js

@@ -54,15 +54,15 @@ export async function render_endpoint(event, mod, state) {
 		}
 
 		return response;
-	} catch (error) {
-		if (error instanceof Redirect) {
+	} catch (e) {
+		if (e instanceof Redirect) {
 			return new Response(undefined, {
-				status: error.status,
-				headers: { location: error.location }
+				status: e.status,
+				headers: { location: e.location }
 			});
 		}
 
-		throw error;
+		throw e;
 	}
 }
 

package/src/runtime/server/fetch.js

@@ -1,16 +1,18 @@
 import * as set_cookie_parser from 'set-cookie-parser';
-import { respond } from './index.js';
+import { respond } from './respond.js';
+import * as paths from '../shared.js';
 
 /**
  * @param {{
  *   event: import('types').RequestEvent;
  *   options: import('types').SSROptions;
+ *   manifest: import('types').SSRManifest;
  *   state: import('types').SSRState;
  *   get_cookie_header: (url: URL, header: string | null) => string;
  * }} opts
  * @returns {typeof fetch}
  */
-export function create_fetch({ event, options, state, get_cookie_header }) {
+export function create_fetch({ event, options, manifest, state, get_cookie_header }) {
 	return async (info, init) => {
 		const original_request = normalize_fetch_input(info, init, event.url);
 
@@ -71,25 +73,25 @@ export function create_fetch({ event, options, state, get_cookie_header }) {
 
 				// handle fetch requests for static assets. e.g. prebaked data, etc.
 				// we need to support everything the browser's fetch supports
-				const prefix = options.paths.assets || options.paths.base;
+				const prefix = paths.assets || paths.base;
 				const decoded = decodeURIComponent(url.pathname);
 				const filename = (
 					decoded.startsWith(prefix) ? decoded.slice(prefix.length) : decoded
 				).slice(1);
 				const filename_html = `${filename}/index.html`; // path may also match path/index.html
 
-				const is_asset = options.manifest.assets.has(filename);
-				const is_asset_html = options.manifest.assets.has(filename_html);
+				const is_asset = manifest.assets.has(filename);
+				const is_asset_html = manifest.assets.has(filename_html);
 
 				if (is_asset || is_asset_html) {
 					const file = is_asset ? filename : filename_html;
 
-					if (options.read) {
+					if (state.read) {
 						const type = is_asset
-							? options.manifest.mimeTypes[filename.slice(filename.lastIndexOf('.'))]
+							? manifest.mimeTypes[filename.slice(filename.lastIndexOf('.'))]
 							: 'text/html';
 
-						return new Response(options.read(file), {
+						return new Response(state.read(file), {
 							headers: type ? { 'content-type': type } : {}
 						});
 					}
@@ -129,7 +131,7 @@ export function create_fetch({ event, options, state, get_cookie_header }) {
 					);
 				}
 
-				response = await respond(request, options, state);
+				response = await respond(request, options, manifest, state);
 
 				const set_cookie = response.headers.get('set-cookie');
 				if (set_cookie) {