chore: prepare hash based routing (#13210)

* pass URL to _preload_code and get_url_path

* add get_route_id

* get_route_id is a misnomer

Author: Rich-Harris

packages/kit/src/runtime/client/client.js

@@ -424,9 +424,9 @@ async function _preload_data(intent) {
 	return load_cache.promise;
 }
 
-/** @param {string} pathname */
-async function _preload_code(pathname) {
-	const route = routes.find((route) => route.exec(get_url_path(pathname)));
+/** @param {URL} url */
+async function _preload_code(url) {
+	const route = routes.find((route) => route.exec(get_url_path(url)));
 
 	if (route) {
 		await Promise.all([...route.layouts, route.leaf].map((load) => load?.[1]()));
@@ -875,7 +875,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 
 	/** @type {import('types').ServerNodesResponse | import('types').ServerRedirectNode | null} */
 	let server_data = null;
-	const url_changed = current.url ? id !== current.url.pathname + current.url.search : false;
+	const url_changed = current.url ? id !== get_page_key(current.url) : false;
 	const route_changed = current.route ? route.id !== current.route.id : false;
 	const search_params_changed = diff_search_params(current.url, url);
 
@@ -1175,7 +1175,12 @@ function get_navigation_intent(url, invalidating) {
 	// reroute could alter the given URL, so we pass a copy
 	let rerouted;
 	try {
-		rerouted = app.hooks.reroute({ url: new URL(url) }) ?? url.pathname;
+		rerouted = app.hooks.reroute({ url: new URL(url) }) ?? url;
+
+		if (typeof rerouted === 'string') {
+			url.pathname = rerouted;
+			rerouted = url;
+		}
 	} catch (e) {
 		if (DEV) {
 			// in development, print the error...
@@ -1195,7 +1200,7 @@ function get_navigation_intent(url, invalidating) {
 		const params = route.exec(path);
 
 		if (params) {
-			const id = url.pathname + url.search;
+			const id = get_page_key(url);
 			/** @type {import('./types.js').NavigationIntent} */
 			const intent = {
 				id,
@@ -1209,9 +1214,14 @@ function get_navigation_intent(url, invalidating) {
 	}
 }
 
-/** @param {string} pathname */
-function get_url_path(pathname) {
-	return decode_pathname(pathname.slice(base.length) || '/');
+/** @param {URL} url */
+function get_url_path(url) {
+	return decode_pathname(url.pathname.slice(base.length) || '/');
+}
+
+/** @param {URL} url */
+function get_page_key(url) {
+	return url.pathname + url.search;
 }
 
 /**
@@ -1547,7 +1557,7 @@ function setup_preload() {
 		(entries) => {
 			for (const entry of entries) {
 				if (entry.isIntersecting) {
-					_preload_code(/** @type {HTMLAnchorElement} */ (entry.target).href);
+					_preload_code(new URL(/** @type {HTMLAnchorElement} */ (entry.target).href));
 					observer.unobserve(entry.target);
 				}
 			}
@@ -1569,7 +1579,7 @@ function setup_preload() {
 		const options = get_router_options(a);
 
 		// we don't want to preload data for a page we're already on
-		const same_url = url && current.url.pathname + current.url.search === url.pathname + url.search;
+		const same_url = url && get_page_key(current.url) === get_page_key(url);
 
 		if (!options.reload && !same_url) {
 			if (priority <= options.preload_data) {
@@ -1591,7 +1601,7 @@ function setup_preload() {
 					}
 				}
 			} else if (priority <= options.preload_code) {
-				_preload_code(/** @type {URL} */ (url).pathname);
+				_preload_code(/** @type {URL} */ (url));
 			}
 		}
 	}
@@ -1611,7 +1621,7 @@ function setup_preload() {
 			}
 
 			if (options.preload_code === PRELOAD_PRIORITIES.eager) {
-				_preload_code(/** @type {URL} */ (url).pathname);
+				_preload_code(/** @type {URL} */ (url));
 			}
 		}
 	}
@@ -1855,19 +1865,21 @@ export function preloadCode(pathname) {
 		throw new Error('Cannot call preloadCode(...) on the server');
 	}
 
+	const url = new URL(pathname, current.url);
+
 	if (DEV) {
 		if (!pathname.startsWith(base)) {
 			throw new Error(
 				`pathnames passed to preloadCode must start with \`paths.base\` (i.e. "${base}${pathname}" rather than "${pathname}")`
 			);
 		}
 
-		if (!routes.find((route) => route.exec(get_url_path(pathname)))) {
+		if (!routes.find((route) => route.exec(get_url_path(url)))) {
 			throw new Error(`'${pathname}' did not match any routes`);
 		}
 	}
 
-	return _preload_code(pathname);
+	return _preload_code(url);
 }
 
 /**