@sveltejs/kit 1.0.0-next.218 → 1.0.0-next.221

package/assets/kit.js

@@ -112,13 +112,14 @@ async function render_endpoint(request, route, match) {
 	const response = await handler(request);
 	const preface = `Invalid response from route ${request.url.pathname}`;
 
-	if (!response) {
-		return;
-	}
 	if (typeof response !== 'object') {
 		return error(`${preface}: expected an object, got ${typeof response}`);
 	}
 
+	if (response.fallthrough) {
+		return;
+	}
+
 	let { status = 200, body, headers = {} } = response;
 
 	headers = lowercase_keys(headers);
@@ -548,6 +549,7 @@ const s = JSON.stringify;
  *   error?: Error,
  *   url: URL;
  *   params: Record<string, string>
+ *   stuff: Record<string, any>;
  * }} opts
  */
 async function render_response({
@@ -558,7 +560,8 @@ async function render_response({
 	status,
 	error,
 	url,
-	params
+	params,
+	stuff
 }) {
 	const css = new Set(options.manifest._.entry.css);
 	const js = new Set(options.manifest._.entry.js);
@@ -599,7 +602,7 @@ async function render_response({
 				navigating: writable(null),
 				session
 			},
-			page: { url, params, status, error },
+			page: { url, params, status, error, stuff },
 			components: branch.map(({ node }) => node.module.default)
 		};
 
@@ -904,7 +907,6 @@ function is_root_relative(path) {
  *   $session: any;
  *   stuff: Record<string, any>;
  *   prerender_enabled: boolean;
- *   is_leaf: boolean;
  *   is_error: boolean;
  *   status?: number;
  *   error?: Error;
@@ -922,7 +924,6 @@ async function load_node({
 	$session,
 	stuff,
 	prerender_enabled,
-	is_leaf,
 	is_error,
 	status,
 	error
@@ -1182,16 +1183,16 @@ async function load_node({
 		}
 
 		loaded = await module.load.call(null, load_input);
+
+		if (!loaded) {
+			throw new Error(`load function must return a value${options.dev ? ` (${node.entry})` : ''}`);
+		}
 	} else {
 		loaded = {};
 	}
 
-	// if leaf node (i.e. page component) has a load function
-	// that returns nothing, we fall through to the next one
-	if (!loaded && is_leaf && !is_error) return;
-
-	if (!loaded) {
-		throw new Error(`${node.entry} - load must return a value except for page fall through`);
+	if (loaded.fallthrough && !is_error) {
+		return;
 	}
 
 	return {
@@ -1222,33 +1223,30 @@ async function load_node({
  * }} opts
  */
 async function respond_with_error({ request, options, state, $session, status, error }) {
-	const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
-	const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
+	try {
+		const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
+		const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
 
-	/** @type {Record<string, string>} */
-	const params = {}; // error page has no params
+		/** @type {Record<string, string>} */
+		const params = {}; // error page has no params
 
-	// error pages don't fall through, so we know it's not undefined
-	const loaded = /** @type {Loaded} */ (
-		await load_node({
-			request,
-			options,
-			state,
-			route: null,
-			url: request.url, // TODO this is redundant, no?
-			params,
-			node: default_layout,
-			$session,
-			stuff: {},
-			prerender_enabled: is_prerender_enabled(options, default_error, state),
-			is_leaf: false,
-			is_error: false
-		})
-	);
+		const layout_loaded = /** @type {Loaded} */ (
+			await load_node({
+				request,
+				options,
+				state,
+				route: null,
+				url: request.url, // TODO this is redundant, no?
+				params,
+				node: default_layout,
+				$session,
+				stuff: {},
+				prerender_enabled: is_prerender_enabled(options, default_error, state),
+				is_error: false
+			})
+		);
 
-	const branch = [
-		loaded,
-		/** @type {Loaded} */ (
+		const error_loaded = /** @type {Loaded} */ (
 			await load_node({
 				request,
 				options,
@@ -1258,17 +1256,14 @@ async function respond_with_error({ request, options, state, $session, status, e
 				params,
 				node: default_error,
 				$session,
-				stuff: loaded ? loaded.stuff : {},
+				stuff: layout_loaded ? layout_loaded.stuff : {},
 				prerender_enabled: is_prerender_enabled(options, default_error, state),
-				is_leaf: false,
 				is_error: true,
 				status,
 				error
 			})
-		)
-	];
+		);
 
-	try {
 		return await render_response({
 			options,
 			$session,
@@ -1277,9 +1272,10 @@ async function respond_with_error({ request, options, state, $session, status, e
 				router: options.router,
 				ssr: options.ssr
 			},
+			stuff: error_loaded.stuff,
 			status,
 			error,
-			branch,
+			branch: [layout_loaded, error_loaded],
 			url: request.url,
 			params
 		});
@@ -1377,9 +1373,9 @@ async function respond$1(opts) {
 	/** @type {string[]} */
 	let set_cookie_headers = [];
 
-	ssr: if (page_config.ssr) {
-		let stuff = {};
+	let stuff = {};
 
+	ssr: if (page_config.ssr) {
 		for (let i = 0; i < nodes.length; i += 1) {
 			const node = nodes[i];
 
@@ -1394,7 +1390,6 @@ async function respond$1(opts) {
 						node,
 						stuff,
 						prerender_enabled: is_prerender_enabled(options, node, state),
-						is_leaf: i === nodes.length - 1,
 						is_error: false
 					});
 
@@ -1451,7 +1446,6 @@ async function respond$1(opts) {
 										node: error_node,
 										stuff: node_loaded.stuff,
 										prerender_enabled: is_prerender_enabled(options, error_node, state),
-										is_leaf: false,
 										is_error: true,
 										status,
 										error
@@ -1464,6 +1458,7 @@ async function respond$1(opts) {
 
 								page_config = get_page_config(error_node.module, options);
 								branch = branch.slice(0, j + 1).concat(error_loaded);
+								stuff = { ...node_loaded.stuff, ...error_loaded.stuff };
 								break ssr;
 							} catch (err) {
 								const e = coalesce_to_error(err);
@@ -1505,6 +1500,7 @@ async function respond$1(opts) {
 		return with_cookies(
 			await render_response({
 				...opts,
+				stuff,
 				url: request.url,
 				page_config,
 				status,
@@ -1845,6 +1841,7 @@ async function respond(incoming, options, state = {}) {
 						params: request.params,
 						options,
 						$session: await options.hooks.getSession(request),
+						stuff: {},
 						page_config: { ssr: false, router: true, hydrate: true },
 						status: 200,
 						branch: []
@@ -1905,16 +1902,30 @@ async function respond(incoming, options, state = {}) {
 				}
 			}
 		});
-	} catch (/** @type {unknown} */ err) {
-		const e = coalesce_to_error(err);
+	} catch (/** @type {unknown} */ e) {
+		const error = coalesce_to_error(e);
 
-		options.handle_error(e, request);
+		options.handle_error(error, request);
 
-		return {
-			status: 500,
-			headers: {},
-			body: options.dev ? e.stack : e.message
-		};
+		try {
+			const $session = await options.hooks.getSession(request);
+			return await respond_with_error({
+				request,
+				options,
+				state,
+				$session,
+				status: 500,
+				error
+			});
+		} catch (/** @type {unknown} */ e) {
+			const error = coalesce_to_error(e);
+
+			return {
+				status: 500,
+				headers: {},
+				body: options.dev ? error.stack : error.message
+			};
+		}
 	}
 }
 

package/assets/runtime/internal/start.js

@@ -168,6 +168,10 @@ class Router {
 				// Call `pushState` to add url to history so going back works.
 				// Also make a delay, otherwise the browser default behaviour would not kick in
 				setTimeout(() => history.pushState({}, '', url.href));
+				const info = this.parse(url);
+				if (info) {
+					return this.renderer.update(info, [], false);
+				}
 				return;
 			}
 
@@ -543,6 +547,9 @@ class Renderer {
 
 		let error_args;
 
+		// url.hash is empty when coming from the server
+		url.hash = window.location.hash;
+
 		try {
 			for (let i = 0; i < nodes.length; i += 1) {
 				const is_leaf = i === nodes.length - 1;
@@ -577,7 +584,14 @@ class Renderer {
 
 			result = error_args
 				? await this._load_error(error_args)
-				: await this._get_navigation_result_from_branch({ url, params, branch, status, error });
+				: await this._get_navigation_result_from_branch({
+						url,
+						params,
+						stuff,
+						branch,
+						status,
+						error
+				  });
 		} catch (e) {
 			if (error) throw e;
 
@@ -801,12 +815,13 @@ class Renderer {
 	 * @param {{
 	 *   url: URL;
 	 *   params: Record<string, string>;
+	 *   stuff: Record<string, any>;
 	 *   branch: Array<import('./types').BranchNode | undefined>;
 	 *   status: number;
 	 *   error?: Error;
 	 * }} opts
 	 */
-	async _get_navigation_result_from_branch({ url, params, branch, status, error }) {
+	async _get_navigation_result_from_branch({ url, params, stuff, branch, status, error }) {
 		const filtered = /** @type {import('./types').BranchNode[] } */ (branch.filter(Boolean));
 		const redirect = filtered.find((f) => f.loaded && f.loaded.redirect);
 
@@ -830,7 +845,7 @@ class Renderer {
 		}
 
 		if (!this.current.url || url.href !== this.current.url.href) {
-			result.props.page = { url, params, status, error };
+			result.props.page = { url, params, status, error, stuff };
 
 			// TODO remove this for 1.0
 			/**
@@ -963,8 +978,9 @@ class Renderer {
 
 			const loaded = await module.load.call(null, load_input);
 
-			// if the page component returns nothing from load, fall through
-			if (!loaded) return;
+			if (!loaded) {
+				throw new Error('load function must return a value');
+			}
 
 			node.loaded = normalize(loaded);
 			if (node.loaded.stuff) node.stuff = node.loaded.stuff;
@@ -1041,9 +1057,10 @@ class Renderer {
 						stuff
 					});
 
-					const is_leaf = i === a.length - 1;
-
 					if (node && node.loaded) {
+						if (node.loaded.fallthrough) {
+							return;
+						}
 						if (node.loaded.error) {
 							status = node.loaded.status;
 							error = node.loaded.error;
@@ -1060,10 +1077,6 @@ class Renderer {
 						if (node.loaded.stuff) {
 							stuff_changed = true;
 						}
-					} else if (is_leaf && module.load) {
-						// if the leaf node has a `load` function
-						// that returns nothing, fall through
-						return;
 					}
 				} else {
 					node = previous;
@@ -1099,6 +1112,13 @@ class Renderer {
 								continue;
 							}
 
+							if (error_loaded && error_loaded.loaded && error_loaded.loaded.stuff) {
+								stuff = {
+									...stuff,
+									...error_loaded.loaded.stuff
+								};
+							}
+
 							branch = branch.slice(0, j + 1).concat(error_loaded);
 							break load;
 						} catch (e) {
@@ -1124,7 +1144,14 @@ class Renderer {
 			}
 		}
 
-		return await this._get_navigation_result_from_branch({ url, params, branch, status, error });
+		return await this._get_navigation_result_from_branch({
+			url,
+			params,
+			stuff,
+			branch,
+			status,
+			error
+		});
 	}
 
 	/**
@@ -1144,20 +1171,26 @@ class Renderer {
 			params,
 			stuff: {}
 		});
+		const error_node = await this._load_node({
+			status,
+			error,
+			module: await this.fallback[1],
+			url,
+			params,
+			stuff: (node && node.loaded && node.loaded.stuff) || {}
+		});
 
-		const branch = [
-			node,
-			await this._load_node({
-				status,
-				error,
-				module: await this.fallback[1],
-				url,
-				params,
-				stuff: (node && node.loaded && node.loaded.stuff) || {}
-			})
-		];
+		const branch = [node, error_node];
+		const stuff = { ...node?.loaded?.stuff, ...error_node?.loaded?.stuff };
 
-		return await this._get_navigation_result_from_branch({ url, params, branch, status, error });
+		return await this._get_navigation_result_from_branch({
+			url,
+			params,
+			stuff,
+			branch,
+			status,
+			error
+		});
 	}
 }