tidy up

templates/src/app/app.ts

@@ -20,7 +20,6 @@ export const pages: Page[] = __PAGES__;
 
 let ready = false;
 let root_component: Component;
-let segments: string[] = [];
 let current_token: {};
 let root_preload: Promise<any>;
 let root_data: any;
@@ -28,7 +27,7 @@ let current_branch = [];
 
 export let prefetching: {
 	href: string;
-	promise: Promise<{ redirect?: Redirect, data?: any, new_segments?: any }>;
+	promise: Promise<{ redirect?: Redirect, data?: any }>;
 } = null;
 export function set_prefetching(href, promise) {
 	prefetching = { href, promise };
@@ -131,16 +130,15 @@ export async function navigate(target: Target, id: number, noscroll?: boolean, h
 
 	const token = current_token = {};
 
-	const { redirect, page, data, new_segments, results } = await loaded;
+	const { redirect, page, data, branch } = await loaded;
 
 	if (redirect) return goto(redirect.location, { replaceState: true });
-	if (new_segments) segments = new_segments;
 
-	await render(results, data, page, scroll_history[id], noscroll, hash, token);
+	await render(branch, data, page, scroll_history[id], noscroll, hash, token);
 	if (document.activeElement) document.activeElement.blur();
 }
 
-async function render(results: any[], props: any, page: PageData, scroll: ScrollPosition, noscroll: boolean, hash: string, token: {}) {
+async function render(branch: any[], props: any, page: PageData, scroll: ScrollPosition, noscroll: boolean, hash: string, token: {}) {
 	if (current_token !== token) return;
 
 	stores.page.set(page);
@@ -189,33 +187,35 @@ async function render(results: any[], props: any, page: PageData, scroll: Scroll
 		if (scroll) scrollTo(scroll.x, scroll.y);
 	}
 
-	current_branch = results;
+	current_branch = branch;
 	ready = true;
 }
 
-export function prepare_page(target: Target): Promise<{
+export async function prepare_page(target: Target): Promise<{
 	redirect?: Redirect;
 	data?: any;
 	page: PageData
 }> {
 	const { page, path, query } = target;
-	const new_segments = path.split('/').filter(Boolean);
+	const segments = path.split('/').filter(Boolean);
-	let changed_from = 0;
-
-	while (
-		segments[changed_from] &&
-		new_segments[changed_from] &&
-		segments[changed_from] === new_segments[changed_from]
-	) changed_from += 1;
-
-	if (changed_from === new_segments.length) {
-		changed_from -= 1;
-	}
 
 	let redirect: Redirect = null;
 	let error: { statusCode: number, message: Error | string } = null;
-	let page_data: PageData;
 
+	if (!root_preload) {
+		const preload_fn = RootStatic['pre' + 'load']; // Rollup makes us jump through these hoops :(
+		root_preload = preload_fn
+			? initial_data.preloaded[0] || preload_fn.call(preload_context, {
+				path,
+				query,
+				params: {}
+			})
+			: {};
+	}
+
+	let branch;
+
+	try {
 		const preload_context = {
 			fetch: (url: string, opts?: any) => fetch(url, opts),
 			redirect: (statusCode: number, location: string) => {
@@ -229,58 +229,38 @@ export function prepare_page(target: Target): Promise<{
 			}
 		};
 
-	if (!root_preload) {
+		branch = await Promise.all(page.parts.map(async (part, i) => {
-		const preload_fn = RootStatic['pre' + 'load']; // Rollup makes us jump through these hoops :(
-		root_preload = preload_fn
-			? initial_data.preloaded[0] || preload_fn.call(preload_context, {
-				path,
-				query,
-				params: {}
-			})
-			: {};
-	}
-
-	return Promise.all(page.parts.map((part, i) => {
-		const segment = new_segments[i];
-
-		if (i < changed_from || !part) return current_branch[i];
 			if (!part) return null;
 
-		return load_component(components[part.i]).then(({ default: Component, preload }) => {
+			const segment = segments[i];
-			page_data = {
+			if (current_branch[i] && current_branch[i].segment === segment) return current_branch[i];
-				path,
+
-				query,
+			const { default: Component, preload } = await load_component(components[part.i]);
-				params: part.params ? part.params(target.match) : {}
-			};
 
 			let preloaded;
 			if (ready || !initial_data.preloaded[i + 1]) {
 				preloaded = preload
-					? preload.call(preload_context, page_data)
+					? await preload.call(preload_context, {
+						path,
+						query,
+						params: part.params ? part.params(target.match) : {}
+					})
 					: {};
 			} else {
 				preloaded = initial_data.preloaded[i + 1];
 			}
 
-			return Promise.resolve(preloaded).then(preloaded => {
+			return { Component, preloaded, segment };
-				return { Component, preloaded };
+		}));
-			});
+	} catch (e) {
-		});
+		error = { statusCode: 500, message: e };
-	})).catch(err => {
+		branch = [];
-		error = { statusCode: 500, message: err };
-		return [];
-	}).then(results => {
-		if (root_data) {
-			return results;
-		} else {
-			return Promise.resolve(root_preload).then(value => {
-				root_data = value;
-				return results;
-			});
 	}
-	}).then(results => {
+
+	if (!root_data) root_data = await root_preload;
+
 	if (redirect) {
-			return { redirect, new_segments, page: null };
+		return { redirect, page: null };
 	}
 
 	const deepest = page.parts[page.parts.length - 1];
@@ -293,7 +273,6 @@ export function prepare_page(target: Target): Promise<{
 
 	if (error) {
 		return {
-				new_segments,
 			page: page_data,
 			data: {
 				child: {
@@ -303,13 +282,14 @@ export function prepare_page(target: Target): Promise<{
 						status: error.statusCode
 					}
 				}
-				}
+			},
+			branch
 		};
 	}
 
 	const props = {
 		child: {
-				segment: new_segments[0]
+			segment: segments[0]
 		}
 	};
 
@@ -319,17 +299,16 @@ export function prepare_page(target: Target): Promise<{
 		const part = page.parts[i];
 		if (!part) continue;
 
-			level.component = results[i].Component;
+		level.component = branch[i].Component;
-			level.props = Object.assign({}, results[i].preloaded, {
+		level.props = Object.assign({}, branch[i].preloaded, {
 			child: {}
 		});
 
 		level = level.props.child;
-			level.segment = new_segments[i + 1];
+		level.segment = segments[i + 1];
 	}
 
-		return { data: props, new_segments, page: page_data, results };
+	return { data: props, page: page_data, branch };
-	});
 }
 
 function load_css(chunk: string) {