@sveltejs/kit 1.0.12 → 1.1.0

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';
@@ -64,15 +64,69 @@ const enforced_config = {
 	root: true
 };
 
+const options_regex = /(export\s+const\s+(prerender|csr|ssr|trailingSlash))\s*=/s;
+
+/** @type {Set<string>} */
+const warned = new Set();
+
+/** @type {import('@sveltejs/vite-plugin-svelte').PreprocessorGroup} */
+const warning_preprocessor = {
+	script: ({ content, filename }) => {
+		if (!filename) return;
+
+		const basename = path.basename(filename);
+		if (basename.startsWith('+page.') || basename.startsWith('+layout.')) {
+			const match = content.match(options_regex);
+			if (match) {
+				const fixed = basename.replace('.svelte', '(.server).js/ts');
+
+				const message =
+					`\n${colors.bold().red(path.relative('.', filename))}\n` +
+					`\`${match[1]}\` will be ignored — move it to ${fixed} instead. See https://kit.svelte.dev/docs/page-options for more information.`;
+
+				if (!warned.has(message)) {
+					console.log(message);
+					warned.add(message);
+				}
+			}
+		}
+	},
+	markup: ({ content, filename }) => {
+		if (!filename) return;
+
+		const basename = path.basename(filename);
+		if (basename.startsWith('+layout.') && !content.includes('<slot')) {
+			const message =
+				`\n${colors.bold().red(path.relative('.', filename))}\n` +
+				`\`<slot />\` missing — inner content will not be rendered`;
+
+			if (!warned.has(message)) {
+				console.log(message);
+				warned.add(message);
+			}
+		}
+	}
+};
+
 /** @return {Promise<import('vite').Plugin[]>} */
 export async function sveltekit() {
 	const svelte_config = await load_config();
 
+	/** @type {import('@sveltejs/vite-plugin-svelte').Options['preprocess']} */
+	let preprocess = svelte_config.preprocess;
+	if (Array.isArray(preprocess)) {
+		preprocess = [...preprocess, warning_preprocessor];
+	} else if (preprocess) {
+		preprocess = [preprocess, warning_preprocessor];
+	} else {
+		preprocess = warning_preprocessor;
+	}
+
 	/** @type {import('@sveltejs/vite-plugin-svelte').Options} */
 	const vite_plugin_svelte_options = {
 		configFile: false,
 		extensions: svelte_config.extensions,
-		preprocess: svelte_config.preprocess,
+		preprocess,
 		onwarn: svelte_config.onwarn,
 		compilerOptions: {
 			// @ts-expect-error SvelteKit requires hydratable true by default
@@ -128,7 +182,6 @@ function kit({ svelte_config }) {
 
 	/**
 	 * @type {{
-	 *   build_dir: string;
 	 *   output_dir: string;
 	 *   client_out_dir: string;
 	 * }}
@@ -147,7 +200,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 +212,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 +242,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 +271,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 +290,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 +306,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 +329,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 +360,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 +411,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 +431,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 +540,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 +558,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 +578,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 +623,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/forms.js

@@ -26,7 +26,11 @@ export function deserialize(result) {
 
 /** @type {import('$app/forms').enhance} */
 export function enhance(form, submit = () => {}) {
-	if (DEV && form.method !== 'post') {
+	if (
+		DEV &&
+		/** @type {HTMLFormElement} */ (HTMLFormElement.prototype.cloneNode.call(form)).method !==
+			'post'
+	) {
 		throw new Error('use:enhance can only be used on <form> fields with method="POST"');
 	}
 

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

@@ -915,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/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/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
@@ -54,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) {