@sveltejs/kit 1.2.10 → 1.3.1

package/package.json

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

package/src/core/adapt/builder.js

@@ -17,13 +17,14 @@ const pipe = promisify(pipeline);
  * @param {{
  *   config: import('types').ValidatedConfig;
  *   build_data: import('types').BuildData;
+ *   server_metadata: import('types').ServerMetadata;
  *   routes: import('types').RouteData[];
  *   prerendered: import('types').Prerendered;
  *   log: import('types').Logger;
  * }} opts
  * @returns {import('types').Builder}
  */
-export function create_builder({ config, build_data, routes, prerendered, log }) {
+export function create_builder({ config, build_data, server_metadata, routes, prerendered, log }) {
 	return {
 		log,
 		rimraf,
@@ -53,18 +54,9 @@ export function create_builder({ config, build_data, routes, prerendered, log })
 		async createEntries(fn) {
 			/** @type {import('types').RouteDefinition[]} */
 			const facades = routes.map((route) => {
-				/** @type {Set<import('types').HttpMethod>} */
-				const methods = new Set();
-
-				if (route.page) {
-					methods.add('GET');
-				}
-
-				if (route.endpoint) {
-					for (const method of build_data.server.methods[route.endpoint.file]) {
-						methods.add(method);
-					}
-				}
+				const methods =
+					/** @type {import('types').HttpMethod[]} */
+					(server_metadata.routes.get(route.id)?.methods);
 
 				return {
 					id: route.id,
@@ -74,7 +66,7 @@ export function create_builder({ config, build_data, routes, prerendered, log })
 						content: segment
 					})),
 					pattern: route.pattern,
-					methods: Array.from(methods)
+					methods
 				};
 			});
 

package/src/core/adapt/index.js

@@ -4,11 +4,12 @@ import { create_builder } from './builder.js';
 /**
  * @param {import('types').ValidatedConfig} config
  * @param {import('types').BuildData} build_data
+ * @param {import('types').ServerMetadata} server_metadata
  * @param {import('types').Prerendered} prerendered
  * @param {import('types').PrerenderMap} prerender_map
- * @param {{ log: import('types').Logger }} opts
+ * @param {import('types').Logger} log
  */
-export async function adapt(config, build_data, prerendered, prerender_map, { log }) {
+export async function adapt(config, build_data, server_metadata, prerendered, prerender_map, log) {
 	const { name, adapt } = config.kit.adapter;
 
 	console.log(colors.bold().cyan(`\n> Using ${name}`));
@@ -16,6 +17,7 @@ export async function adapt(config, build_data, prerendered, prerender_map, { lo
 	const builder = create_builder({
 		config,
 		build_data,
+		server_metadata,
 		routes: build_data.manifest_data.routes.filter((route) => {
 			if (!route.page && !route.endpoint) return false;
 

package/src/core/config/options.js

@@ -226,6 +226,10 @@ const options = object(
 				files: fun((filename) => !/\.DS_Store/.test(filename))
 			}),
 
+			typescript: object({
+				config: fun((config) => config)
+			}),
+
 			version: object({
 				name: string(Date.now().toString()),
 				pollInterval: number(0)
@@ -362,7 +366,7 @@ function list(options, fallback = options[0]) {
 }
 
 /**
- * @param {(filename: string) => boolean} fallback
+ * @param {(...args: any) => any} fallback
  * @returns {Validator}
  */
 function fun(fallback) {

package/src/core/generate_manifest/index.js

@@ -86,7 +86,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 		assets: new Set(${s(assets)}),
 		mimeTypes: ${s(get_mime_lookup(build_data.manifest_data))},
 		_: {
-			entry: ${s(build_data.client.entry)},
+			entry: ${s(build_data.client_entry)},
 			nodes: [
 				${(node_paths).map(loader).join(',\n\t\t\t\t')}
 			],
@@ -103,7 +103,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 					pattern: ${route.pattern},
 					params: ${s(route.params)},
 					page: ${route.page ? `{ layouts: ${get_nodes(route.page.layouts)}, errors: ${get_nodes(route.page.errors)}, leaf: ${reindexed.get(route.page.leaf)} }` : 'null'},
-					endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server.vite_manifest, route.endpoint.file).chunk.file)) : 'null'}
+					endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, route.endpoint.file).chunk.file)) : 'null'}
 				}`;
 				}).filter(Boolean).join(',\n\t\t\t\t')}
 			],

package/src/core/postbuild/analyse.js

@@ -0,0 +1,135 @@
+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 { forked } from '../../utils/fork.js';
+import { should_polyfill } from '../../utils/platform.js';
+import { installPolyfills } from '../../exports/node/polyfills.js';
+
+export default forked(import.meta.url, analyse);
+
+/**
+ * @param {{
+ *   manifest_path: string;
+ *   env: Record<string, string>
+ * }} opts
+ */
+async function analyse({ manifest_path, env }) {
+	/** @type {import('types').SSRManifest} */
+	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
+
+	/** @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);
+
+	if (should_polyfill) {
+		installPolyfills();
+	}
+
+	// configure `import { building } from '$app/environment'` —
+	// essential we do this before analysing the code
+	internal.set_building(true);
+
+	// set env, in case it's used in initialisation
+	const entries = Object.entries(env);
+	const prefix = config.env.publicPrefix;
+	internal.set_private_env(Object.fromEntries(entries.filter(([k]) => !k.startsWith(prefix))));
+	internal.set_public_env(Object.fromEntries(entries.filter(([k]) => k.startsWith(prefix))));
+
+	/** @type {import('types').ServerMetadata} */
+	const metadata = {
+		nodes: [],
+		routes: new Map()
+	};
+
+	// analyse nodes
+	for (const loader of manifest._.nodes) {
+		const node = await loader();
+
+		metadata.nodes.push({
+			has_server_load: node.server?.load !== undefined
+		});
+	}
+
+	// analyse routes
+	for (const route of manifest._.routes) {
+		/** @type {Set<import('types').HttpMethod>} */
+		const methods = new Set();
+
+		/** @type {import('types').PrerenderOption | undefined} */
+		let prerender = undefined;
+
+		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 = mod.prerender;
+			}
+
+			if (mod.GET) methods.add('GET');
+			if (mod.POST) methods.add('POST');
+			if (mod.PUT) methods.add('PUT');
+			if (mod.PATCH) methods.add('PATCH');
+			if (mod.DELETE) methods.add('DELETE');
+		}
+
+		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) {
+				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);
+			}
+
+			const should_prerender = get_option(nodes, 'prerender');
+			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);
+		}
+
+		metadata.routes.set(route.id, {
+			prerender,
+			methods: Array.from(methods)
+		});
+	}
+
+	return metadata;
+}

package/src/core/postbuild/prerender.js

@@ -1,68 +1,72 @@
-import { readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { URL } from 'url';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+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 { queue } from './queue.js';
-import { crawl } from './crawl.js';
 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 { queue } from './queue.js';
+import { crawl } from './crawl.js';
+import { forked } from '../../utils/fork.js';
 
-/**
- * @template {{message: string}} T
- * @template {Omit<T, 'message'>} K
- * @param {import('types').Logger} log
- * @param {'fail' | 'warn' | 'ignore' | ((details: T) => void)} input
- * @param {(details: K) => string} format
- * @returns {(details: K) => void}
- */
-function normalise_error_handler(log, input, format) {
-	switch (input) {
-		case 'fail':
-			return (details) => {
-				throw new Error(format(details));
-			};
-		case 'warn':
-			return (details) => {
-				log.error(format(details));
-			};
-		case 'ignore':
-			return () => {};
-		default:
-			// @ts-expect-error TS thinks T might be of a different kind, but it's not
-			return (details) => input({ ...details, message: format(details) });
-	}
-}
-
-const OK = 2;
-const REDIRECT = 3;
+export default forked(import.meta.url, prerender);
 
 /**
- *
  * @param {{
- *   Server: typeof import('types').InternalServer;
- *   internal: import('types').ServerInternalModule;
- *   manifest: import('types').SSRManifest;
- *   prerender_map: import('types').PrerenderMap;
- *   client_out_dir: string;
- *   verbose: string;
- *   env: Record<string, string>;
+ *   out: string;
+ *   manifest_path: string;
+ *   metadata: import('types').ServerMetadata;
+ *   verbose: boolean;
+ *   env: Record<string, string>
  * }} opts
- * @returns
  */
-export async function prerender({
-	Server,
-	internal,
-	manifest,
-	prerender_map,
-	client_out_dir,
-	verbose,
-	env
-}) {
+async function prerender({ out, manifest_path, metadata, verbose, env }) {
+	/** @type {import('types').SSRManifest} */
+	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
+
+	/** @type {import('types').ServerInternalModule} */
+	const internal = await import(pathToFileURL(`${out}/server/internal.js`).href);
+
+	/** @type {import('types').ServerModule} */
+	const { Server } = await import(pathToFileURL(`${out}/server/index.js`).href);
+
+	// configure `import { building } from '$app/environment'` —
+	// essential we do this before analysing the code
+	internal.set_building(true);
+
+	/**
+	 * @template {{message: string}} T
+	 * @template {Omit<T, 'message'>} K
+	 * @param {import('types').Logger} log
+	 * @param {'fail' | 'warn' | 'ignore' | ((details: T) => void)} input
+	 * @param {(details: K) => string} format
+	 * @returns {(details: K) => void}
+	 */
+	function normalise_error_handler(log, input, format) {
+		switch (input) {
+			case 'fail':
+				return (details) => {
+					throw new Error(format(details));
+				};
+			case 'warn':
+				return (details) => {
+					log.error(format(details));
+				};
+			case 'ignore':
+				return () => {};
+			default:
+				// @ts-expect-error TS thinks T might be of a different kind, but it's not
+				return (details) => input({ ...details, message: format(details) });
+		}
+	}
+
+	const OK = 2;
+	const REDIRECT = 3;
+
 	/** @type {import('types').Prerendered} */
 	const prerendered = {
 		pages: new Map(),
@@ -71,6 +75,15 @@ export async function prerender({
 		paths: []
 	};
 
+	/** @type {import('types').PrerenderMap} */
+	const prerender_map = new Map();
+
+	for (const [id, { prerender }] of metadata.routes) {
+		if (prerender !== undefined) {
+			prerender_map.set(id, prerender);
+		}
+	}
+
 	/** @type {Set<string>} */
 	const prerendered_routes = new Set();
 
@@ -78,9 +91,7 @@ export async function prerender({
 	const config = (await load_config()).kit;
 
 	/** @type {import('types').Logger} */
-	const log = logger({
-		verbose: verbose === 'true'
-	});
+	const log = logger({ verbose });
 
 	if (should_polyfill) {
 		installPolyfills();
@@ -134,7 +145,7 @@ export async function prerender({
 		return file;
 	}
 
-	const files = new Set(walk(client_out_dir).map(posixify));
+	const files = new Set(walk(`${out}/client`).map(posixify));
 	const seen = new Set();
 	const written = new Set();
 

package/src/core/sync/sync.js

@@ -1,7 +1,6 @@
 import path from 'path';
 import create_manifest_data from './create_manifest_data/index.js';
 import { write_client_manifest } from './write_client_manifest.js';
-import { write_matchers } from './write_matchers.js';
 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';
@@ -27,10 +26,9 @@ export async function create(config) {
 
 	const output = path.join(config.kit.outDir, 'generated');
 
-	write_client_manifest(config, manifest_data, output);
+	write_client_manifest(config.kit, manifest_data, `${output}/client`);
 	write_server(config, output);
 	write_root(manifest_data, output);
-	write_matchers(manifest_data, output);
 	await write_all_types(config, manifest_data);
 
 	return { manifest_data };
@@ -72,7 +70,7 @@ export async function all_types(config, mode) {
 }
 
 /**
- * Regenerate server-internal.js in response to src/{app.html,error.html,service-worker.js} changing
+ * 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) {

package/src/core/sync/ts.js

@@ -0,0 +1,6 @@
+/** @type {import('typescript')} */
+// @ts-ignore
+export let ts = undefined;
+try {
+	ts = (await import('typescript')).default;
+} catch {}

package/src/core/sync/write_client_manifest.js

@@ -5,11 +5,12 @@ import { trim, write_if_changed } from './utils.js';
 /**
  * Writes the client manifest to disk. The manifest is used to power the router. It contains the
  * list of routes and corresponding Svelte components (i.e. pages and layouts).
- * @param {import('types').ValidatedConfig} config
+ * @param {import('types').ValidatedKitConfig} kit
  * @param {import('types').ManifestData} manifest_data
  * @param {string} output
+ * @param {Array<{ has_server_load: boolean }>} [metadata]
  */
-export function write_client_manifest(config, manifest_data, output) {
+export function write_client_manifest(kit, manifest_data, output, metadata) {
 	/**
 	 * Creates a module that exports a `CSRPageNode`
 	 * @param {import('types').PageNode} node
@@ -32,15 +33,16 @@ export function write_client_manifest(config, manifest_data, output) {
 			);
 		}
 
-		if (node.server) {
-			declarations.push(`export const has_server_load = true;`);
-		}
-
 		return declarations.join('\n');
 	}
 
+	/** @type {Map<import('types').PageNode, number>} */
+	const indices = new Map();
+
 	const nodes = manifest_data.nodes
 		.map((node, i) => {
+			indices.set(node, i);
+
 			write_if_changed(`${output}/nodes/${i}.js`, generate_node(node));
 			return `() => import('./nodes/${i}')`;
 		})
@@ -58,14 +60,35 @@ export function write_client_manifest(config, manifest_data, output) {
 					while (layouts.at(-1) === '') layouts.pop();
 					while (errors.at(-1) === '') errors.pop();
 
+					let leaf_has_server_load = false;
+					if (route.leaf) {
+						if (metadata) {
+							const i = /** @type {number} */ (indices.get(route.leaf));
+							leaf_has_server_load = metadata[i].has_server_load;
+						} else if (route.leaf.server) {
+							leaf_has_server_load = true;
+						}
+					}
+
 					// Encode whether or not the route uses server data
 					// using the ones' complement, to save space
-					const array = [`${route.leaf?.server ? '~' : ''}${route.page.leaf}`];
+					const array = [`${leaf_has_server_load ? '~' : ''}${route.page.leaf}`];
+
 					// Encode whether or not the layout uses server data.
 					// It's a different method compared to pages because layouts
-					// are reused across pages, so we safe space by doing it this way.
+					// are reused across pages, so we save space by doing it this way.
 					route.page.layouts.forEach((layout) => {
-						if (layout != undefined && manifest_data.nodes[layout].server) {
+						if (layout == undefined) return;
+
+						let layout_has_server_load = false;
+
+						if (metadata) {
+							layout_has_server_load = metadata[layout].has_server_load;
+						} else if (manifest_data.nodes[layout].server) {
+							layout_has_server_load = true;
+						}
+
+						if (layout_has_server_load) {
 							layouts_with_server_load.add(layout);
 						}
 					});
@@ -81,15 +104,15 @@ export function write_client_manifest(config, manifest_data, output) {
 			.join(',\n\t\t')}
 	}`.replace(/^\t/gm, '');
 
-	const hooks_file = resolve_entry(config.kit.files.hooks.client);
+	const hooks_file = resolve_entry(kit.files.hooks.client);
 
-	// String representation of __GENERATED__/client-manifest.js
+	// String representation of __CLIENT__/manifest.js
 	write_if_changed(
-		`${output}/client-manifest.js`,
+		`${output}/manifest.js`,
 		trim(`
 			${hooks_file ? `import * as client_hooks from '${relative_path(output, hooks_file)}';` : ''}
 
-			export { matchers } from './client-matchers.js';
+			export { matchers } from './matchers.js';
 
 			export const nodes = [${nodes}];
 
@@ -104,4 +127,22 @@ export function write_client_manifest(config, manifest_data, output) {
 			};
 		`)
 	);
+
+	// write matchers to a separate module so that we don't
+	// need to worry about name conflicts
+	const imports = [];
+	const matchers = [];
+
+	for (const key in manifest_data.matchers) {
+		const src = manifest_data.matchers[key];
+
+		imports.push(`import { match as ${key} } from ${s(relative_path(output, src))};`);
+		matchers.push(key);
+	}
+
+	const module = imports.length
+		? `${imports.join('\n')}\n\nexport const matchers = { ${matchers.join(', ')} };`
+		: 'export const matchers = {};';
+
+	write_if_changed(`${output}/matchers.js`, module);
 }

package/src/core/sync/write_server.js

@@ -4,6 +4,7 @@ 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';
+import { write_if_changed } from './utils.js';
 
 /**
  * @param {{
@@ -23,7 +24,7 @@ const server_template = ({
 	template,
 	error_page
 }) => `
-import root from './root.svelte';
+import root from '../root.svelte';
 import { set_building, set_paths, set_private_env, set_public_env, set_version } from '${runtime_directory}/shared.js';
 
 set_paths(${s(config.kit.paths)});
@@ -75,11 +76,11 @@ export function write_server(config, output) {
 
 	/** @param {string} file */
 	function relative(file) {
-		return posixify(path.relative(output, file));
+		return posixify(path.relative(`${output}/server`, file));
 	}
 
-	fs.writeFileSync(
-		`${output}/server-internal.js`,
+	write_if_changed(
+		`${output}/server/internal.js`,
 		server_template({
 			config,
 			hooks: fs.existsSync(hooks_file) ? relative(hooks_file) : null,