@sveltejs/kit 1.0.12 → 1.1.0

package/package.json

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

package/src/core/adapt/builder.js

@@ -126,7 +126,7 @@ export function create_builder({ config, build_data, routes, prerendered, log })
 
 		generateFallback(dest) {
 			// do prerendering in a subprocess so any dangling stuff gets killed upon completion
-			const script = fileURLToPath(new URL('../prerender/fallback.js', import.meta.url));
+			const script = fileURLToPath(new URL('../postbuild/fallback.js', import.meta.url));
 
 			const manifest_path = `${config.kit.outDir}/output/server/manifest-full.js`;
 

package/src/core/{prerender → postbuild}/fallback.js

@@ -14,17 +14,19 @@ installPolyfills();
 
 const server_root = join(config.outDir, 'output');
 
+/** @type {import('types').ServerInternalModule} */
+const { set_building, set_paths } = await import(
+	pathToFileURL(`${server_root}/server/internal.js`).href
+);
+
 /** @type {import('types').ServerModule} */
-const { Server, override } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
+const { Server } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
 
 /** @type {import('types').SSRManifest} */
 const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
-override({
-	building: true,
-	paths: config.paths,
-	read: (file) => readFileSync(join(config.files.assets, file))
-});
+set_building(true);
+set_paths(config.paths);
 
 const server = new Server(manifest);
 await server.init({ env: JSON.parse(env) });
@@ -36,7 +38,8 @@ const rendered = await server.respond(new Request(config.prerender.origin + '/[f
 	prerendering: {
 		fallback: true,
 		dependencies: new Map()
-	}
+	},
+	read: (file) => readFileSync(join(config.files.assets, file))
 });
 
 mkdirp(dirname(dest));

package/src/core/postbuild/index.js

@@ -0,0 +1,106 @@
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { get_option } from '../../runtime/server/utils.js';
+import {
+	validate_common_exports,
+	validate_page_server_exports,
+	validate_server_exports
+} from '../../utils/exports.js';
+import { load_config } from '../config/index.js';
+import { prerender } from './prerender.js';
+
+const [, , client_out_dir, manifest_path, results_path, verbose, env] = process.argv;
+
+/** @type {import('types').SSRManifest} */
+const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
+
+/** @type {import('types').PrerenderMap} */
+const prerender_map = new Map();
+
+/** @type {import('types').ValidatedKitConfig} */
+const config = (await load_config()).kit;
+
+const server_root = join(config.outDir, 'output');
+
+/** @type {import('types').ServerInternalModule} */
+const internal = await import(pathToFileURL(`${server_root}/server/internal.js`).href);
+
+/** @type {import('types').ServerModule} */
+const { Server } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
+
+// configure `import { building } from '$app/environment'` —
+// essential we do this before analysing the code
+internal.set_building(true);
+
+// analyse routes
+for (const route of manifest._.routes) {
+	if (route.endpoint) {
+		const mod = await route.endpoint();
+		if (mod.prerender !== undefined) {
+			validate_server_exports(mod, route.id);
+
+			if (mod.prerender && (mod.POST || mod.PATCH || mod.PUT || mod.DELETE)) {
+				throw new Error(
+					`Cannot prerender a +server file with POST, PATCH, PUT, or DELETE (${route.id})`
+				);
+			}
+
+			prerender_map.set(route.id, mod.prerender);
+		}
+	}
+
+	if (route.page) {
+		const nodes = await Promise.all(
+			[...route.page.layouts, route.page.leaf].map((n) => {
+				if (n !== undefined) return manifest._.nodes[n]();
+			})
+		);
+
+		const layouts = nodes.slice(0, -1);
+		const page = nodes.at(-1);
+
+		for (const layout of layouts) {
+			if (layout) {
+				validate_common_exports(layout.server, route.id);
+				validate_common_exports(layout.universal, route.id);
+			}
+		}
+
+		if (page) {
+			validate_page_server_exports(page.server, route.id);
+			validate_common_exports(page.universal, route.id);
+		}
+
+		const should_prerender = get_option(nodes, 'prerender');
+		const prerender =
+			should_prerender === true ||
+			// Try prerendering if ssr is false and no server needed. Set it to 'auto' so that
+			// the route is not removed from the manifest, there could be a server load function.
+			// People can opt out of this behavior by explicitly setting prerender to false
+			(should_prerender !== false && get_option(nodes, 'ssr') === false && !page?.server?.actions
+				? 'auto'
+				: should_prerender ?? false);
+
+		prerender_map.set(route.id, prerender);
+	}
+}
+
+const { prerendered } = await prerender({
+	Server,
+	internal,
+	manifest,
+	prerender_map,
+	client_out_dir,
+	verbose,
+	env
+});
+
+writeFileSync(
+	results_path,
+	JSON.stringify({ prerendered, prerender_map }, (_key, value) =>
+		value instanceof Map ? Array.from(value.entries()) : value
+	)
+);
+
+process.exit(0);

package/src/core/{prerender → postbuild}/prerender.js

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
-import { pathToFileURL, URL } from 'url';
+import { URL } from 'url';
 import { installPolyfills } from '../../exports/node/polyfills.js';
 import { mkdirp, posixify, walk } from '../../utils/filesystem.js';
 import { should_polyfill } from '../../utils/platform.js';
@@ -11,16 +11,6 @@ import { escape_html_attr } from '../../utils/escape.js';
 import { logger } from '../utils.js';
 import { load_config } from '../config/index.js';
 import { get_route_segments } from '../../utils/routing.js';
-import { get_option } from '../../runtime/server/utils.js';
-import {
-	validate_common_exports,
-	validate_page_server_exports,
-	validate_server_exports
-} from '../../utils/exports.js';
-
-const [, , client_out_dir, manifest_path, results_path, verbose, env] = process.argv;
-
-prerender();
 
 /**
  * @template {{message: string}} T
@@ -52,22 +42,27 @@ const OK = 2;
 const REDIRECT = 3;
 
 /**
+ *
  * @param {{
- *   prerendered: import('types').Prerendered;
+ *   Server: typeof import('types').InternalServer;
+ *   internal: import('types').ServerInternalModule;
+ *   manifest: import('types').SSRManifest;
  *   prerender_map: import('types').PrerenderMap;
- * }} data
+ *   client_out_dir: string;
+ *   verbose: string;
+ *   env: string;
+ * }} opts
+ * @returns
  */
-const output_and_exit = (data) => {
-	writeFileSync(
-		results_path,
-		JSON.stringify(data, (_key, value) =>
-			value instanceof Map ? Array.from(value.entries()) : value
-		)
-	);
-	process.exit(0);
-};
-
-export async function prerender() {
+export async function prerender({
+	Server,
+	internal,
+	manifest,
+	prerender_map,
+	client_out_dir,
+	verbose,
+	env
+}) {
 	/** @type {import('types').Prerendered} */
 	const prerendered = {
 		pages: new Map(),
@@ -76,9 +71,6 @@ export async function prerender() {
 		paths: []
 	};
 
-	/** @type {import('types').PrerenderMap} */
-	const prerender_map = new Map();
-
 	/** @type {Set<string>} */
 	const prerendered_routes = new Set();
 
@@ -94,29 +86,10 @@ export async function prerender() {
 		installPolyfills();
 	}
 
-	const server_root = join(config.outDir, 'output');
-
-	/** @type {import('types').ServerModule} */
-	const { Server, override } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
-
-	/** @type {import('types').SSRManifest} */
-	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
-
 	/** @type {Map<string, string>} */
 	const saved = new Map();
 
-	override({
-		building: true,
-		paths: config.paths,
-		read: (file) => {
-			// stuff we just wrote
-			const filepath = saved.get(file);
-			if (filepath) return readFileSync(filepath);
-
-			// stuff in `static`
-			return readFileSync(join(config.files.assets, file));
-		}
-	});
+	internal.set_paths(config.paths);
 
 	const server = new Server(manifest);
 	await server.init({ env: JSON.parse(env) });
@@ -201,9 +174,19 @@ export async function prerender() {
 		const dependencies = new Map();
 
 		const response = await server.respond(new Request(config.prerender.origin + encoded), {
-			getClientAddress,
+			getClientAddress() {
+				throw new Error('Cannot read clientAddress during prerendering');
+			},
 			prerendering: {
 				dependencies
+			},
+			read: (file) => {
+				// stuff we just wrote
+				const filepath = saved.get(file);
+				if (filepath) return readFileSync(filepath);
+
+				// stuff in `static`
+				return readFileSync(join(config.files.assets, file));
 			}
 		});
 
@@ -367,58 +350,6 @@ export async function prerender() {
 		saved.set(file, dest);
 	}
 
-	for (const route of manifest._.routes) {
-		if (route.endpoint) {
-			const mod = await route.endpoint();
-			if (mod.prerender !== undefined) {
-				validate_server_exports(mod, route.id);
-
-				if (mod.prerender && (mod.POST || mod.PATCH || mod.PUT || mod.DELETE)) {
-					throw new Error(
-						`Cannot prerender a +server file with POST, PATCH, PUT, or DELETE (${route.id})`
-					);
-				}
-
-				prerender_map.set(route.id, mod.prerender);
-			}
-		}
-
-		if (route.page) {
-			const nodes = await Promise.all(
-				[...route.page.layouts, route.page.leaf].map((n) => {
-					if (n !== undefined) return manifest._.nodes[n]();
-				})
-			);
-
-			const layouts = nodes.slice(0, -1);
-			const page = nodes.at(-1);
-
-			for (const layout of layouts) {
-				if (layout) {
-					validate_common_exports(layout.server, route.id);
-					validate_common_exports(layout.universal, route.id);
-				}
-			}
-
-			if (page) {
-				validate_page_server_exports(page.server, route.id);
-				validate_common_exports(page.universal, route.id);
-			}
-
-			const should_prerender = get_option(nodes, 'prerender');
-			const prerender =
-				should_prerender === true ||
-				// Try prerendering if ssr is false and no server needed. Set it to 'auto' so that
-				// the route is not removed from the manifest, there could be a server load function.
-				// People can opt out of this behavior by explicitly setting prerender to false
-				(should_prerender !== false && get_option(nodes, 'ssr') === false && !page?.server?.actions
-					? 'auto'
-					: should_prerender ?? false);
-
-			prerender_map.set(route.id, prerender);
-		}
-	}
-
 	for (const entry of config.prerender.entries) {
 		if (entry === '*') {
 			for (const [id, prerender] of prerender_map) {
@@ -467,10 +398,5 @@ export async function prerender() {
 		);
 	}
 
-	output_and_exit({ prerendered, prerender_map });
-}
-
-/** @return {string} */
-function getClientAddress() {
-	throw new Error('Cannot read clientAddress during prerendering');
+	return { prerendered, prerender_map };
 }

package/src/core/sync/sync.js

@@ -6,6 +6,7 @@ import { write_root } from './write_root.js';
 import { write_tsconfig } from './write_tsconfig.js';
 import { write_types, write_all_types } from './write_types/index.js';
 import { write_ambient } from './write_ambient.js';
+import { write_server } from './write_server.js';
 
 /**
  * Initialize SvelteKit's generated files.
@@ -27,6 +28,7 @@ export async function create(config) {
 	const output = path.join(config.kit.outDir, 'generated');
 
 	write_client_manifest(config, manifest_data, output);
+	write_server(config, output);
 	write_root(manifest_data, output);
 	write_matchers(manifest_data, output);
 	await write_all_types(config, manifest_data);
@@ -57,3 +59,11 @@ export async function all(config, mode) {
 	init(config, mode);
 	return await create(config);
 }
+
+/**
+ * Regenerate server-internal.js in response to src/{app.html,error.html,service-worker.js} changing
+ * @param {import('types').ValidatedConfig} config
+ */
+export function server(config) {
+	write_server(config, path.join(config.kit.outDir, 'generated'));
+}

package/src/core/sync/write_client_manifest.js

@@ -33,7 +33,7 @@ export function write_client_manifest(config, manifest_data, output) {
 		}
 
 		if (node.server) {
-			declarations.push(`export const server = true;`);
+			declarations.push(`export const has_server_load = true;`);
 		}
 
 		return declarations.join('\n');

package/src/core/sync/write_server.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { posixify, resolve_entry } from '../../utils/filesystem.js';
+import { s } from '../../utils/misc.js';
+import { load_error_page, load_template } from '../config/index.js';
+import { runtime_directory } from '../utils.js';
+
+/**
+ * @param {{
+ *   hooks: string | null;
+ *   config: import('types').ValidatedConfig;
+ *   has_service_worker: boolean;
+ *   runtime_directory: string;
+ *   template: string;
+ *   error_page: string;
+ * }} opts
+ */
+const server_template = ({
+	config,
+	hooks,
+	has_service_worker,
+	runtime_directory,
+	template,
+	error_page
+}) => `
+import root from './root.svelte';
+import { set_building, set_paths, set_version } from '${runtime_directory}/shared.js';
+
+set_paths(${s(config.kit.paths)});
+set_version(${s(config.kit.version.name)});
+
+export const options = {
+	csp: ${s(config.kit.csp)},
+	csrf_check_origin: ${s(config.kit.csrf.checkOrigin)},
+	embedded: ${config.kit.embedded},
+	env_public_prefix: '${config.kit.env.publicPrefix}',
+	hooks: null, // added lazily, via \`get_hooks\`
+	root,
+	service_worker: ${has_service_worker},
+	templates: {
+		app: ({ head, body, assets, nonce }) => ${s(template)
+			.replace('%sveltekit.head%', '" + head + "')
+			.replace('%sveltekit.body%', '" + body + "')
+			.replace(/%sveltekit\.assets%/g, '" + assets + "')
+			.replace(/%sveltekit\.nonce%/g, '" + nonce + "')},
+		error: ({ status, message }) => ${s(error_page)
+			.replace(/%sveltekit\.status%/g, '" + status + "')
+			.replace(/%sveltekit\.error\.message%/g, '" + message + "')}
+	}
+};
+
+export function get_hooks() {
+	return ${hooks ? `import(${s(hooks)})` : '{}'};
+}
+
+export { set_building, set_paths };
+`;
+
+// TODO need to re-run this whenever src/app.html or src/error.html are
+// created or changed, or src/service-worker.js is created or deleted.
+// Also, need to check that updating hooks.server.js works
+
+/**
+ * Write server configuration to disk
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} output
+ */
+export function write_server(config, output) {
+	// TODO the casting shouldn't be necessary — investigate
+	const hooks_file = /** @type {string} */ (resolve_entry(config.kit.files.hooks.server));
+
+	/** @param {string} file */
+	function relative(file) {
+		return posixify(path.relative(output, file));
+	}
+
+	fs.writeFileSync(
+		`${output}/server-internal.js`,
+		server_template({
+			config,
+			hooks: fs.existsSync(hooks_file) ? relative(hooks_file) : null,
+			has_service_worker:
+				config.kit.serviceWorker.register && !!resolve_entry(config.kit.files.serviceWorker),
+			runtime_directory: relative(runtime_directory),
+			template: load_template(process.cwd(), config),
+			error_page: load_error_page(config)
+		})
+	);
+}

package/src/core/sync/write_tsconfig.js

@@ -60,6 +60,15 @@ export function write_tsconfig(config, cwd = process.cwd()) {
 	include.push(config_relative(`${test_folder}/**/*.ts`));
 	include.push(config_relative(`${test_folder}/**/*.svelte`));
 
+	const exclude = [config_relative('node_modules/**'), './[!ambient.d.ts]**'];
+	if (path.extname(config.files.serviceWorker)) {
+		exclude.push(config_relative(config.files.serviceWorker));
+	} else {
+		exclude.push(config_relative(`${config.files.serviceWorker}.js`));
+		exclude.push(config_relative(`${config.files.serviceWorker}.ts`));
+		exclude.push(config_relative(`${config.files.serviceWorker}.d.ts`));
+	}
+
 	write_if_changed(
 		out,
 		JSON.stringify(
@@ -88,7 +97,7 @@ export function write_tsconfig(config, cwd = process.cwd()) {
 					target: 'esnext'
 				},
 				include,
-				exclude: [config_relative('node_modules/**'), './[!ambient.d.ts]**']
+				exclude
 			},
 			null,
 			'\t'

package/src/core/utils.js

@@ -13,9 +13,6 @@ import { posixify, to_fs } from '../utils/filesystem.js';
  */
 export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', import.meta.url)));
 
-/** Prefix for the `runtime` directory, for use with import declarations */
-export const runtime_prefix = posixify_path(runtime_directory);
-
 /**
  * This allows us to import SvelteKit internals that aren't exposed via `pkg.exports` in a
  * way that works whether `@sveltejs/kit` is installed inside the project's `node_modules`
@@ -25,12 +22,6 @@ export const runtime_base = runtime_directory.startsWith(process.cwd())
 	? `/${path.relative('.', runtime_directory)}`
 	: to_fs(runtime_directory);
 
-/** @param {string} str */
-function posixify_path(str) {
-	const parsed = path.parse(str);
-	return `/${parsed.dir.slice(parsed.root.length).split(path.sep).join('/')}/${parsed.base}`;
-}
-
 function noop() {}
 
 /** @param {{ verbose: boolean }} opts */