@sveltejs/kit 1.0.0-next.431 → 1.0.0-next.434

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

@@ -7,11 +7,12 @@ declare module '__GENERATED__/client-manifest.js' {
 	export const nodes: CSRPageNodeLoader[];
 
 	/**
-	 * A map of `[routeId: string]: [errors, layouts, page]` tuples, which
+	 * A map of `[routeId: string]: [leaf, layouts, errors]` tuples, which
 	 * is parsed into an array of routes on startup. The numbers refer to the
-	 * indices in `nodes`.
+	 * indices in `nodes`. The route layout and error nodes are not referenced,
+	 * they are always number 0 and 1 and always apply.
 	 */
-	export const dictionary: Record<string, [number[], number[], number]>;
+	export const dictionary: Record<string, [leaf: number, layouts?: number[], errors?: number[]]>;
 
 	export const matchers: Record<string, ParamMatcher>;
 }

package/src/runtime/client/client.js

@@ -825,15 +825,10 @@ export function create_client({ target, base, trailing_slash }) {
 						}
 					}
 
-					// TODO post-https://github.com/sveltejs/kit/discussions/6124, this will
-					// no longer be necessary — if we get here, it's because the root layout
-					// load function failed, which means we have to fall back to the server
-					return await load_root_error_page({
-						status,
-						error,
-						url,
-						routeId: route.id
-					});
+					// if we get here, it's because the root `load` function failed,
+					// and we need to fall back to the server
+					native_navigation(url);
+					return;
 				}
 			} else {
 				// push an empty slot so we can rewind past gaps to the

package/src/runtime/client/parse.js

@@ -2,14 +2,19 @@ import { exec, parse_route_id } from '../../utils/routing.js';
 
 /**
  * @param {import('types').CSRPageNodeLoader[]} nodes
- * @param {Record<string, [number[], number[], number, 1?]>} dictionary
+ * @param {typeof import('__GENERATED__/client-manifest.js').dictionary} dictionary
  * @param {Record<string, (param: string) => boolean>} matchers
  * @returns {import('types').CSRRoute[]}
  */
 export function parse(nodes, dictionary, matchers) {
-	return Object.entries(dictionary).map(([id, [errors, layouts, leaf, uses_server_data]]) => {
+	return Object.entries(dictionary).map(([id, [leaf, layouts, errors]]) => {
 		const { pattern, names, types } = parse_route_id(id);
 
+		// whether or not the route uses the server data is
+		// encoded using the ones' complement, to save space
+		const uses_server_data = leaf < 0;
+		if (uses_server_data) leaf = ~leaf;
+
 		const route = {
 			id,
 			/** @param {string} path */
@@ -17,10 +22,10 @@ export function parse(nodes, dictionary, matchers) {
 				const match = pattern.exec(path);
 				if (match) return exec(match, names, types, matchers);
 			},
-			errors: errors.map((n) => nodes[n]),
-			layouts: layouts.map((n) => nodes[n]),
+			errors: [1, ...(errors || [])].map((n) => nodes[n]),
+			layouts: [0, ...(layouts || [])].map((n) => nodes[n]),
 			leaf: nodes[leaf],
-			uses_server_data: !!uses_server_data
+			uses_server_data
 		};
 
 		// bit of a hack, but ensures that layout/error node lists are the same

package/src/runtime/server/endpoint.js

@@ -3,14 +3,12 @@ import { check_method_names, method_not_allowed } from './utils.js';
 
 /**
  * @param {import('types').RequestEvent} event
- * @param {import('types').SSREndpoint} route
+ * @param {import('types').SSREndpoint} mod
  * @returns {Promise<Response>}
  */
-export async function render_endpoint(event, route) {
+export async function render_endpoint(event, mod) {
 	const method = /** @type {import('types').HttpMethod} */ (event.request.method);
 
-	const mod = await route.load();
-
 	// TODO: Remove for 1.0
 	check_method_names(mod);
 
@@ -21,12 +19,6 @@ export async function render_endpoint(event, route) {
 	}
 
 	if (!handler) {
-		if (event.request.headers.get('x-sveltekit-load')) {
-			// TODO would be nice to avoid these requests altogether,
-			// by noting whether or not page endpoints export `get`
-			return new Response(undefined, { status: 204 });
-		}
-
 		return method_not_allowed(mod, method);
 	}
 

package/src/runtime/server/index.js

@@ -93,7 +93,7 @@ export async function respond(request, options, state) {
 	}
 
 	if (route) {
-		if (route.type === 'page') {
+		if (route.page) {
 			const normalized = normalize_path(url.pathname, options.trailing_slash);
 
 			if (normalized !== url.pathname && !state.prerendering?.fallback) {
@@ -253,9 +253,9 @@ export async function respond(request, options, state) {
 				if (route) {
 					/** @type {Response} */
 					let response;
-					if (is_data_request && route.type === 'page') {
+					if (is_data_request && route.page) {
 						try {
-							const node_ids = [...route.layouts, route.leaf];
+							const node_ids = [...route.page.layouts, route.page.leaf];
 
 							const invalidated =
 								request.headers.get('x-sveltekit-invalidated')?.split(',').map(Boolean) ??
@@ -317,7 +317,8 @@ export async function respond(request, options, state) {
 											throw error;
 										}
 
-										length = i + 1; // don't include nodes after first 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} */ ({
@@ -358,11 +359,14 @@ export async function respond(request, options, state) {
 								response = json(error_to_pojo(error, options.get_stack), { status: 500 });
 							}
 						}
+					} else if (route.page) {
+						response = await render_page(event, route, route.page, options, state, resolve_opts);
+					} else if (route.endpoint) {
+						response = await render_endpoint(event, await route.endpoint());
 					} else {
-						response =
-							route.type === 'endpoint'
-								? await render_endpoint(event, route)
-								: await render_page(event, route, options, state, resolve_opts);
+						// a route will always have a page or an endpoint, but TypeScript
+						// doesn't know that
+						throw new Error('This should never happen');
 					}
 
 					if (!is_data_request) {

package/src/runtime/server/page/fetch.js

@@ -9,7 +9,7 @@ import { domain_matches, path_matches } from './cookie.js';
  *   event: import('types').RequestEvent;
  *   options: import('types').SSROptions;
  *   state: import('types').SSRState;
- *   route: import('types').SSRPage | import('types').SSRErrorPage;
+ *   route: import('types').SSRRoute | import('types').SSRErrorPage;
  * }} opts
  */
 export function create_fetch({ event, options, state, route }) {

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

@@ -5,6 +5,7 @@ import { method_not_allowed, error_to_pojo, allowed_methods } from '../utils.js'
 import { create_fetch } from './fetch.js';
 import { HttpError, Redirect } from '../../../index/private.js';
 import { error, json } from '../../../index/index.js';
+import { compact } from '../../../utils/array.js';
 import { normalize_error } from '../../../utils/error.js';
 import { load_data, load_server_data } from './load_data.js';
 
@@ -17,13 +18,14 @@ import { load_data, load_server_data } from './load_data.js';
 
 /**
  * @param {import('types').RequestEvent} event
- * @param {import('types').SSRPage} route
+ * @param {import('types').SSRRoute} route
+ * @param {import('types').PageNodeIndexes} page
  * @param {import('types').SSROptions} options
  * @param {import('types').SSRState} state
  * @param {import('types').RequiredResolveOptions} resolve_opts
  * @returns {Promise<Response>}
  */
-export async function render_page(event, route, options, state, resolve_opts) {
+export async function render_page(event, route, page, options, state, resolve_opts) {
 	if (state.initiator === route) {
 		// infinite request cycle detected
 		return new Response(`Not found: ${event.url.pathname}`, {
@@ -41,7 +43,7 @@ export async function render_page(event, route, options, state, resolve_opts) {
 		event.request.method !== 'GET' &&
 		event.request.method !== 'HEAD'
 	) {
-		const node = await options.manifest._.nodes[route.leaf]();
+		const node = await options.manifest._.nodes[page.leaf]();
 		if (node.server) {
 			return handle_json_request(event, options, node.server);
 		}
@@ -52,8 +54,8 @@ export async function render_page(event, route, options, state, resolve_opts) {
 	try {
 		const nodes = await Promise.all([
 			// we use == here rather than === because [undefined] serializes as "[null]"
-			...route.layouts.map((n) => (n == undefined ? n : options.manifest._.nodes[n]())),
-			options.manifest._.nodes[route.leaf]()
+			...page.layouts.map((n) => (n == undefined ? n : options.manifest._.nodes[n]())),
+			options.manifest._.nodes[page.leaf]()
 		]);
 
 		const leaf_node = /** @type {import('types').SSRNode} */ (nodes.at(-1));
@@ -244,8 +246,8 @@ export async function render_page(event, route, options, state, resolve_opts) {
 					const status = error instanceof HttpError ? error.status : 500;
 
 					while (i--) {
-						if (route.errors[i]) {
-							const index = /** @type {number} */ (route.errors[i]);
+						if (page.errors[i]) {
+							const index = /** @type {number} */ (page.errors[i]);
 							const node = await options.manifest._.nodes[index]();
 
 							let j = i;
@@ -400,18 +402,3 @@ function redirect_response(status, location) {
 		headers: { location }
 	});
 }
-
-/**
- * @template T
- * @param {Array<T | null>} array
- * @returns {T[]}
- */
-function compact(array) {
-	const compacted = [];
-	for (const item of array) {
-		if (item) {
-			compacted.push(item);
-		}
-	}
-	return compacted;
-}

package/src/utils/array.js

@@ -0,0 +1,9 @@
+/**
+ * Removes nullish values from an array.
+ *
+ * @template T
+ * @param {Array<T>} arr
+ */
+export function compact(arr) {
+	return arr.filter(/** @returns {val is NonNullable<T>} */ (val) => val != null);
+}

package/src/utils/routing.js

@@ -12,12 +12,21 @@ export function parse_route_id(id) {
 	// const add_trailing_slash = !/\.[a-z]+$/.test(key);
 	let add_trailing_slash = true;
 
+	if (/\]\[/.test(id)) {
+		throw new Error(`Invalid route ${id} — parameters must be separated`);
+	}
+
+	if (count_occurrences('[', id) !== count_occurrences(']', id)) {
+		throw new Error(`Invalid route ${id} — brackets are unbalanced`);
+	}
+
 	const pattern =
 		id === ''
 			? /^\/$/
 			: new RegExp(
 					`^${id
-						.split(/(?:@[a-zA-Z0-9_-]+)?(?:\/|$)/)
+						.split(/(?:\/|$)/)
+						.filter(affects_path)
 						.map((segment, i, segments) => {
 							const decoded_segment = decodeURIComponent(segment);
 							// special case — /[...rest]/ could contain zero segments
@@ -79,6 +88,14 @@ export function parse_route_id(id) {
 	return { pattern, names, types };
 }
 
+/**
+ * Returns `false` for `(group)` segments
+ * @param {string} segment
+ */
+export function affects_path(segment) {
+	return !/^\([^)]+\)$/.test(segment);
+}
+
 /**
  * @param {RegExpMatchArray} match
  * @param {string[]} names
@@ -106,3 +123,15 @@ export function exec(match, names, types, matchers) {
 
 	return params;
 }
+
+/**
+ * @param {string} needle
+ * @param {string} haystack
+ */
+function count_occurrences(needle, haystack) {
+	let count = 0;
+	for (let i = 0; i < haystack.length; i += 1) {
+		if (haystack[i] === needle) count += 1;
+	}
+	return count;
+}

package/src/vite/build/build_server.js

@@ -84,7 +84,12 @@ export class Server {
 		};
 	}
 
-	init({ env }) {
+	/**
+	 * Take care: Some adapters may have to call \`Server.init\` per-request to set env vars,
+	 * so anything that shouldn't be rerun should be wrapped in an \`if\` block to make sure it hasn't
+	 * been done already.
+	 */
+	async init({ env }) {
 		const entries = Object.entries(env);
 
 		const prv = Object.fromEntries(entries.filter(([k]) => !k.startsWith('${
@@ -99,12 +104,6 @@ export class Server {
 		set_public_env(pub);
 
 		this.options.public_env = pub;
-	}
-
-	async respond(request, options = {}) {
-		if (!(request instanceof Request)) {
-			throw new Error('The first argument to server.respond must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
-		}
 
 		if (!this.options.hooks) {
 			const module = await import(${s(hooks)});
@@ -114,6 +113,12 @@ export class Server {
 				externalFetch: module.externalFetch || fetch
 			};
 		}
+	}
+
+	async respond(request, options = {}) {
+		if (!(request instanceof Request)) {
+			throw new Error('The first argument to server.respond must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
+		}
 
 		return respond(request, this.options, options);
 	}
@@ -158,8 +163,8 @@ export async function build_server(options, client) {
 
 	// add entry points for every endpoint...
 	manifest_data.routes.forEach((route) => {
-		if (route.type === 'endpoint') {
-			const resolved = path.resolve(cwd, route.file);
+		if (route.endpoint) {
+			const resolved = path.resolve(cwd, route.endpoint.file);
 			const relative = decodeURIComponent(path.relative(config.kit.files.routes, resolved));
 			const name = posixify(path.join('entries/endpoints', relative.replace(/\.js$/, '')));
 			input[name] = resolved;
@@ -326,10 +331,16 @@ function get_methods(cwd, output, manifest_data) {
 	/** @type {Record<string, import('types').HttpMethod[]>} */
 	const methods = {};
 	manifest_data.routes.forEach((route) => {
-		const file = route.type === 'endpoint' ? route.file : route.leaf.server;
+		if (route.endpoint) {
+			if (lookup[route.endpoint.file]) {
+				methods[route.endpoint.file] = lookup[route.endpoint.file].filter(is_http_method);
+			}
+		}
 
-		if (file && lookup[file]) {
-			methods[file] = lookup[file].filter(is_http_method);
+		if (route.leaf?.server) {
+			if (lookup[route.leaf.server]) {
+				methods[route.leaf.server] = lookup[route.leaf.server].filter(is_http_method);
+			}
 		}
 	});
 

package/src/vite/dev/index.js

@@ -7,12 +7,12 @@ import { getRequest, setResponse } from '../../node/index.js';
 import { installPolyfills } from '../../node/polyfills.js';
 import { coalesce_to_error } from '../../utils/error.js';
 import { posixify } from '../../utils/filesystem.js';
-import { parse_route_id } from '../../utils/routing.js';
 import { load_template } from '../../core/config/index.js';
 import { SVELTE_KIT_ASSETS } from '../../core/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';
+import { compact } from '../../utils/array.js';
 
 // Vite doesn't expose this so we just copy the list for now
 // https://github.com/vitejs/vite/blob/3edd1af56e980aef56641a5a51cf2932bb580d41/packages/vite/src/node/plugins/css.ts#L96
@@ -149,36 +149,27 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 						return result;
 					};
 				}),
-				routes: manifest_data.routes.map((route) => {
-					const { pattern, names, types } = parse_route_id(route.id);
+				routes: compact(
+					manifest_data.routes.map((route) => {
+						if (!route.page && !route.endpoint) return null;
+
+						const endpoint = route.endpoint;
 
-					if (route.type === 'page') {
 						return {
-							type: 'page',
 							id: route.id,
-							pattern,
-							names,
-							types,
-							errors: route.errors.map((id) => (id ? manifest_data.nodes.indexOf(id) : undefined)),
-							layouts: route.layouts.map((id) =>
-								id ? manifest_data.nodes.indexOf(id) : undefined
-							),
-							leaf: manifest_data.nodes.indexOf(route.leaf)
+							pattern: route.pattern,
+							names: route.names,
+							types: route.types,
+							page: route.page,
+							endpoint: endpoint
+								? async () => {
+										const url = path.resolve(cwd, endpoint.file);
+										return await vite.ssrLoadModule(url);
+								  }
+								: null
 						};
-					}
-
-					return {
-						type: 'endpoint',
-						id: route.id,
-						pattern,
-						names,
-						types,
-						load: async () => {
-							const url = path.resolve(cwd, route.file);
-							return await vite.ssrLoadModule(url);
-						}
-					};
-				}),
+					})
+				),
 				matchers: async () => {
 					/** @type {Record<string, import('types').ParamMatcher>} */
 					const matchers = {};
@@ -229,15 +220,16 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 			to_run();
 		}, 100);
 	};
+
 	// Debounce add/unlink events because in case of folder deletion or moves
 	// they fire in rapid succession, causing needless invocations.
 	watch('add', () => debounce(update_manifest));
 	watch('unlink', () => debounce(update_manifest));
 	watch('change', (file) => {
 		// Don't run for a single file if the whole manifest is about to get updated
-		if (!timeout) {
-			sync.update(svelte_config, manifest_data, file);
-		}
+		if (timeout) return;
+
+		sync.update(svelte_config, manifest_data, file);
 	});
 
 	const assets = svelte_config.kit.paths.assets ? SVELTE_KIT_ASSETS : svelte_config.kit.paths.base;

package/src/vite/index.js

@@ -411,7 +411,13 @@ function kit() {
 
 				const child = fork(
 					script,
-					[vite_config.build.outDir, results_path, manifest_path, '' + verbose],
+					[
+						vite_config.build.outDir,
+						results_path,
+						manifest_path,
+						'' + verbose,
+						JSON.stringify({ ...env.private, ...env.public })
+					],
 					{
 						stdio: 'inherit'
 					}

package/src/vite/preview/index.js

@@ -45,7 +45,7 @@ export async function preview(vite, vite_config, svelte_config) {
 	});
 
 	const server = new Server(manifest);
-	server.init({
+	await server.init({
 		env: loadEnv(vite_config.mode, process.cwd(), '')
 	});
 

package/types/index.d.ts

@@ -264,7 +264,7 @@ export interface ResolveOptions {
 
 export class Server {
 	constructor(manifest: SSRManifest);
-	init(options: ServerInitOptions): void;
+	init(options: ServerInitOptions): Promise<void>;
 	respond(request: Request, options: RequestOptions): Promise<Response>;
 }
 

package/types/internal.d.ts

@@ -80,13 +80,6 @@ export type CSRRoute = {
 	uses_server_data: boolean;
 };
 
-export interface EndpointData {
-	type: 'endpoint';
-	id: string;
-	pattern: RegExp;
-	file: string;
-}
-
 export type GetParams = (match: RegExpExecArray) => Record<string, string>;
 
 export interface Hooks {
@@ -101,7 +94,7 @@ export interface ImportNode {
 }
 
 export class InternalServer extends Server {
-	init(options: ServerInitOptions): void;
+	init(options: ServerInitOptions): Promise<void>;
 	respond(
 		request: Request,
 		options: RequestOptions & {
@@ -123,18 +116,12 @@ export interface MethodOverride {
 }
 
 export interface PageNode {
+	depth: number;
 	component?: string; // TODO supply default component if it's missing (bit of an edge case)
 	shared?: string;
 	server?: string;
-}
-
-export interface PageData {
-	type: 'page';
-	id: string;
-	pattern: RegExp;
-	errors: Array<PageNode | undefined>;
-	layouts: Array<PageNode | undefined>;
-	leaf: PageNode;
+	parent_id?: string;
+	parent?: PageNode;
 }
 
 export type PayloadScriptAttributes =
@@ -167,7 +154,34 @@ export interface Respond {
 	(request: Request, options: SSROptions, state: SSRState): Promise<Response>;
 }
 
-export type RouteData = PageData | EndpointData;
+/**
+ * Represents a route segment in the app. It can either be an intermediate node
+ * with only layout/error pages, or a leaf, at which point either `page` and `leaf`
+ * or `endpoint` is set.
+ */
+export interface RouteData {
+	id: string;
+	parent: RouteData | null;
+
+	segment: string;
+	pattern: RegExp;
+	names: string[];
+	types: string[];
+
+	layout: PageNode | null;
+	error: PageNode | null;
+	leaf: PageNode | null;
+
+	page: {
+		layouts: Array<number | undefined>;
+		errors: Array<number | undefined>;
+		leaf: number;
+	} | null;
+
+	endpoint: {
+		file: string;
+	} | null;
+}
 
 export type ServerData =
 	| {
@@ -228,15 +242,6 @@ export interface SSRComponent {
 
 export type SSRComponentLoader = () => Promise<SSRComponent>;
 
-export interface SSREndpoint {
-	type: 'endpoint';
-	id: string;
-	pattern: RegExp;
-	names: string[];
-	types: string[];
-	load(): Promise<Partial<Record<HttpMethod, RequestHandler>>>;
-}
-
 export interface SSRNode {
 	component: SSRComponentLoader;
 	/** index into the `components` array in client-manifest.js */
@@ -309,27 +314,33 @@ export interface SSROptions {
 	trailing_slash: TrailingSlash;
 }
 
-export interface SSRPage {
-	type: 'page';
-	id: string;
-	pattern: RegExp;
-	names: string[];
-	types: string[];
+export interface SSRErrorPage {
+	id: '__error';
+}
+
+export interface PageNodeIndexes {
 	errors: Array<number | undefined>;
 	layouts: Array<number | undefined>;
 	leaf: number;
 }
 
-export interface SSRErrorPage {
-	id: '__error';
-}
+export type SSREndpoint = Partial<Record<HttpMethod, RequestHandler>>;
 
-export type SSRRoute = SSREndpoint | SSRPage;
+export interface SSRRoute {
+	id: string;
+	pattern: RegExp;
+	names: string[];
+	types: string[];
+
+	page: PageNodeIndexes | null;
+
+	endpoint: (() => Promise<SSREndpoint>) | null;
+}
 
 export interface SSRState {
 	fallback?: string;
 	getClientAddress: () => string;
-	initiator?: SSRPage | SSRErrorPage;
+	initiator?: SSRRoute | SSRErrorPage;
 	platform?: any;
 	prerendering?: PrerenderOptions;
 }