@sveltejs/kit 1.0.0-next.435 → 1.0.0-next.438

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.435",
+  "version": "1.0.0-next.438",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -39,7 +39,7 @@
     "tiny-glob": "^0.2.9",
     "typescript": "^4.7.4",
     "uvu": "^0.5.3",
-    "vite": "^3.0.8"
+    "vite": "^3.0.9"
   },
   "peerDependencies": {
     "svelte": "^3.44.0",

package/src/core/adapt/builder.js

@@ -5,6 +5,7 @@ import { pipeline } from 'stream';
 import { promisify } from 'util';
 import { copy, rimraf, mkdirp } from '../../utils/filesystem.js';
 import { generate_manifest } from '../generate_manifest/index.js';
+import { get_path } from '../../utils/routing.js';
 
 /**
  * Creates the Builder which is passed to adapters for building the application.
@@ -23,7 +24,7 @@ export function create_builder({ config, build_data, prerendered, log }) {
 	/** @param {import('types').RouteData} route */
 	// TODO routes should come pre-filtered
 	function not_prerendered(route) {
-		const path = route.page && !route.id.includes('[') && `/${route.id}`;
+		const path = route.page && get_path(route.id);
 		if (path) {
 			return !prerendered_paths.has(path) && !prerendered_paths.has(path + '/');
 		}

package/src/core/prerender/prerender.js

@@ -9,6 +9,8 @@ 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 { compact } from '../../utils/array.js';
+import { get_path } from '../../utils/routing.js';
 
 /**
  * @typedef {import('types').PrerenderErrorHandler} PrerenderErrorHandler
@@ -341,11 +343,10 @@ export async function prerender() {
 	if (config.prerender.enabled) {
 		for (const entry of config.prerender.entries) {
 			if (entry === '*') {
-				/** @type {import('types').ManifestData} */
-				const { routes } = (await import(pathToFileURL(manifest_path).href)).manifest._;
-				const entries = routes
-					.map((route) => (route.page && !route.id.includes('[') ? `/${route.id}` : ''))
-					.filter(Boolean);
+				/** @type {import('types').SSRManifest} */
+				const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
+				const { routes } = manifest._;
+				const entries = compact(routes.map((route) => route.page && get_path(route.id)));
 
 				for (const entry of entries) {
 					enqueue(null, config.paths.base + entry); // TODO can we pre-normalize these?

package/src/core/sync/create_manifest_data/index.js

@@ -82,6 +82,7 @@ function create_matchers(config, cwd) {
  * @param {string} fallback
  */
 function create_routes_and_nodes(cwd, config, fallback) {
+	/** @type {Map<string, import('types').RouteData>} */
 	const route_map = new Map();
 
 	/** @type {Map<string, import('./types').Part[][]>} */

package/src/runtime/client/client.js

@@ -1,6 +1,6 @@
 import { onMount, tick } from 'svelte';
 import { normalize_error } from '../../utils/error.js';
-import { LoadURL, decode_params, normalize_path } from '../../utils/url.js';
+import { make_trackable, decode_params, normalize_path } from '../../utils/url.js';
 import { find_anchor, get_base_uri, get_href, scroll_state } from './utils.js';
 import { lock_fetch, unlock_fetch, initial_fetch, native_fetch } from './fetcher.js';
 import { parse } from './parse.js';
@@ -510,17 +510,14 @@ export function create_client({ target, base, trailing_slash }) {
 				});
 			}
 
-			const load_url = new LoadURL(url);
-
 			/** @type {import('types').LoadEvent} */
 			const load_input = {
 				routeId,
 				params: uses_params,
 				data: server_data_node?.data ?? null,
-				get url() {
+				url: make_trackable(url, () => {
 					uses.url = true;
-					return load_url;
-				},
+				}),
 				async fetch(resource, init) {
 					let requested;
 

package/src/runtime/server/index.js

@@ -4,7 +4,7 @@ import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
 import { coalesce_to_error, normalize_error } from '../../utils/error.js';
 import { serialize_error, GENERIC_ERROR, error_to_pojo } from './utils.js';
-import { decode_params, normalize_path } from '../../utils/url.js';
+import { decode_params, disable_search, normalize_path } from '../../utils/url.js';
 import { exec } from '../../utils/routing.js';
 import { negotiate } from '../../utils/http.js';
 import { HttpError, Redirect } from '../../index/private.js';
@@ -122,21 +122,17 @@ export async function respond(request, options, state) {
 	/** @type {string[]} */
 	const cookies = [];
 
+	if (state.prerendering) disable_search(url);
+
 	/** @type {import('types').RequestEvent} */
 	const event = {
-		get clientAddress() {
-			if (!state.getClientAddress) {
+		getClientAddress:
+			state.getClientAddress ||
+			(() => {
 				throw new Error(
 					`${__SVELTEKIT_ADAPTER_NAME__} does not specify getClientAddress. Please raise an issue`
 				);
-			}
-
-			Object.defineProperty(event, 'clientAddress', {
-				value: state.getClientAddress()
-			});
-
-			return event.clientAddress;
-		},
+			}),
 		locals: {},
 		params,
 		platform: state.platform,
@@ -195,6 +191,7 @@ export async function respond(request, options, state) {
 	};
 
 	Object.defineProperties(event, {
+		clientAddress: removed('clientAddress', 'getClientAddress'),
 		method: removed('method', 'request.method', details),
 		headers: removed('headers', 'request.headers', details),
 		origin: removed('origin', 'url.origin'),
@@ -277,6 +274,7 @@ export async function respond(request, options, state) {
 										return load_server_data({
 											dev: options.dev,
 											event,
+											state,
 											node,
 											parent: async () => {
 												/** @type {Record<string, any>} */

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

@@ -104,6 +104,27 @@ export async function render_page(event, route, page, options, state, resolve_op
 		const should_prerender_data = nodes.some((node) => node?.server);
 		const data_pathname = `${event.url.pathname.replace(/\/$/, '')}/__data.json`;
 
+		// it's crucial that we do this before returning the non-SSR response, otherwise
+		// SvelteKit will erroneously believe that the path has been prerendered,
+		// causing functions to be omitted from the manifesst generated later
+		const should_prerender =
+			leaf_node.shared?.prerender ?? leaf_node.server?.prerender ?? options.prerender.default;
+		if (should_prerender) {
+			const mod = leaf_node.server;
+			if (mod && (mod.POST || mod.PUT || mod.DELETE || mod.PATCH)) {
+				throw new Error('Cannot prerender pages that have endpoints with mutative methods');
+			}
+		} else if (state.prerendering) {
+			// if the page isn't marked as prerenderable (or is explicitly
+			// marked NOT prerenderable, if `prerender.default` is `true`),
+			// then bail out at this point
+			if (!should_prerender) {
+				return new Response(undefined, {
+					status: 204
+				});
+			}
+		}
+
 		if (!resolve_opts.ssr) {
 			return await render_response({
 				branch: [],
@@ -123,24 +144,6 @@ export async function render_page(event, route, page, options, state, resolve_op
 			});
 		}
 
-		const should_prerender =
-			leaf_node.shared?.prerender ?? leaf_node.server?.prerender ?? options.prerender.default;
-		if (should_prerender) {
-			const mod = leaf_node.server;
-			if (mod && (mod.POST || mod.PUT || mod.DELETE || mod.PATCH)) {
-				throw new Error('Cannot prerender pages that have endpoints with mutative methods');
-			}
-		} else if (state.prerendering) {
-			// if the page isn't marked as prerenderable (or is explicitly
-			// marked NOT prerenderable, if `prerender.default` is `true`),
-			// then bail out at this point
-			if (!should_prerender) {
-				return new Response(undefined, {
-					status: 204
-				});
-			}
-		}
-
 		/** @type {Array<Loaded | null>} */
 		let branch = [];
 
@@ -165,6 +168,7 @@ export async function render_page(event, route, page, options, state, resolve_op
 					return await load_server_data({
 						dev: options.dev,
 						event,
+						state,
 						node,
 						parent: async () => {
 							/** @type {Record<string, any>} */

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

@@ -1,16 +1,17 @@
-import { LoadURL, PrerenderingURL } from '../../../utils/url.js';
+import { disable_search, make_trackable } from '../../../utils/url.js';
 
 /**
  * Calls the user's `load` function.
  * @param {{
  *   dev: boolean;
  *   event: import('types').RequestEvent;
+ *   state: import('types').SSRState;
  *   node: import('types').SSRNode | undefined;
  *   parent: () => Promise<Record<string, any>>;
  * }} opts
  * @returns {Promise<import('types').ServerDataNode | null>}
  */
-export async function load_server_data({ dev, event, node, parent }) {
+export async function load_server_data({ dev, event, state, node, parent }) {
 	if (!node?.server) return null;
 
 	const uses = {
@@ -20,39 +21,34 @@ export async function load_server_data({ dev, event, node, parent }) {
 		url: false
 	};
 
-	/** @param {string[]} deps */
-	function depends(...deps) {
-		for (const dep of deps) {
-			const { href } = new URL(dep, event.url);
-			uses.dependencies.add(href);
-		}
-	}
-
-	const params = new Proxy(event.params, {
-		get: (target, key) => {
-			uses.params.add(key);
-			return target[/** @type {string} */ (key)];
-		}
+	const url = make_trackable(event.url, () => {
+		uses.url = true;
 	});
 
+	if (state.prerendering) {
+		disable_search(url);
+	}
+
 	const result = await node.server.load?.call(null, {
-		// can't use destructuring here because it will always
-		// invoke event.clientAddress, which breaks prerendering
-		get clientAddress() {
-			return event.clientAddress;
+		...event,
+		/** @param {string[]} deps */
+		depends: (...deps) => {
+			for (const dep of deps) {
+				const { href } = new URL(dep, event.url);
+				uses.dependencies.add(href);
+			}
 		},
-		depends,
-		locals: event.locals,
-		params,
+		params: new Proxy(event.params, {
+			get: (target, key) => {
+				uses.params.add(key);
+				return target[/** @type {string} */ (key)];
+			}
+		}),
 		parent: async () => {
 			uses.parent = true;
 			return parent();
 		},
-		platform: event.platform,
-		request: event.request,
-		routeId: event.routeId,
-		setHeaders: event.setHeaders,
-		url: event.url
+		url
 	});
 
 	const data = result ? await unwrap_promises(result) : null;
@@ -85,15 +81,15 @@ export async function load_server_data({ dev, event, node, parent }) {
  * }} opts
  * @returns {Promise<Record<string, any> | null>}
  */
-export async function load_data({ event, fetcher, node, parent, server_data_promise, state }) {
+export async function load_data({ event, fetcher, node, parent, server_data_promise }) {
 	const server_data_node = await server_data_promise;
 
 	if (!node?.shared?.load) {
 		return server_data_node?.data ?? null;
 	}
 
-	const load_input = {
-		url: state.prerendering ? new PrerenderingURL(event.url) : new LoadURL(event.url),
+	const load_event = {
+		url: event.url,
 		params: event.params,
 		data: server_data_node?.data ?? null,
 		routeId: event.routeId,
@@ -104,7 +100,7 @@ export async function load_data({ event, fetcher, node, parent, server_data_prom
 	};
 
 	// TODO remove this for 1.0
-	Object.defineProperties(load_input, {
+	Object.defineProperties(load_event, {
 		session: {
 			get() {
 				throw new Error(
@@ -115,7 +111,7 @@ export async function load_data({ event, fetcher, node, parent, server_data_prom
 		}
 	});
 
-	const data = await node.shared.load.call(null, load_input);
+	const data = await node.shared.load.call(null, load_event);
 
 	return data ? unwrap_promises(data) : null;
 }

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

@@ -5,7 +5,6 @@ import { hash } from '../../hash.js';
 import { render_json_payload_script } from '../../../utils/escape.js';
 import { s } from '../../../utils/misc.js';
 import { Csp } from './csp.js';
-import { PrerenderingURL } from '../../../utils/url.js';
 import { serialize_error } from '../utils.js';
 import { HttpError } from '../../../index/private.js';
 
@@ -100,7 +99,7 @@ export async function render_response({
 			params: /** @type {Record<string, any>} */ (event.params),
 			routeId: event.routeId,
 			status,
-			url: state.prerendering ? new PrerenderingURL(event.url) : event.url,
+			url: event.url,
 			data
 		};
 

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

@@ -37,6 +37,7 @@ export async function respond_with_error({ event, options, state, status, error,
 			const server_data_promise = load_server_data({
 				dev: options.dev,
 				event,
+				state,
 				node: default_layout,
 				parent: async () => ({})
 			});

package/src/utils/routing.js

@@ -96,6 +96,15 @@ export function affects_path(segment) {
 	return !/^\([^)]+\)$/.test(segment);
 }
 
+/**
+ * Turns a route ID into a path, if possible
+ * @param {string} id
+ */
+export function get_path(id) {
+	if (id.includes('[')) return null;
+	return `/${id.split('/').filter(affects_path).join('/')}`;
+}
+
 /**
  * @param {RegExpMatchArray} match
  * @param {string[]} names

package/src/utils/url.js

@@ -75,23 +75,68 @@ export function decode_params(params) {
 	return params;
 }
 
-export class LoadURL extends URL {
-	/** @returns {string} */
-	get hash() {
-		throw new Error(
-			'url.hash is inaccessible from load. Consider accessing hash from the page store within the script tag of your component.'
-		);
+/**
+ * URL properties that could change during the lifetime of the page,
+ * which excludes things like `origin`
+ * @type {Array<keyof URL>}
+ */
+const tracked_url_properties = ['href', 'pathname', 'search', 'searchParams', 'toString', 'toJSON'];
+
+/**
+ * @param {URL} url
+ * @param {() => void} callback
+ */
+export function make_trackable(url, callback) {
+	const tracked = new URL(url);
+
+	for (const property of tracked_url_properties) {
+		let value = tracked[property];
+
+		Object.defineProperty(tracked, property, {
+			get() {
+				callback();
+				return value;
+			},
+
+			enumerable: true,
+			configurable: true
+		});
 	}
+
+	// @ts-ignore
+	tracked[Symbol.for('nodejs.util.inspect.custom')] = (depth, opts, inspect) => {
+		return inspect(url, opts);
+	};
+
+	disable_hash(tracked);
+
+	return tracked;
 }
 
-export class PrerenderingURL extends URL {
-	/** @returns {string} */
-	get search() {
-		throw new Error('Cannot access url.search on a page with prerendering enabled');
-	}
+/**
+ * Disallow access to `url.hash` on the server and in `load`
+ * @param {URL} url
+ */
+export function disable_hash(url) {
+	Object.defineProperty(url, 'hash', {
+		get() {
+			throw new Error(
+				'Cannot access event.url.hash. Consider using `$page.url.hash` inside a component instead'
+			);
+		}
+	});
+}
 
-	/** @returns {URLSearchParams} */
-	get searchParams() {
-		throw new Error('Cannot access url.searchParams on a page with prerendering enabled');
+/**
+ * Disallow access to `url.search` and `url.searchParams` during prerendering
+ * @param {URL} url
+ */
+export function disable_search(url) {
+	for (const property of ['search', 'searchParams']) {
+		Object.defineProperty(url, property, {
+			get() {
+				throw new Error(`Cannot access url.${property} on a page with prerendering enabled`);
+			}
+		});
 	}
 }

package/src/vite/index.js

@@ -58,9 +58,7 @@ const enforced_config = {
 	root: true
 };
 
-/**
- * @return {import('vite').Plugin[]}
- */
+/** @return {import('vite').Plugin[]} */
 export function sveltekit() {
 	return [...svelte(), kit()];
 }

package/types/ambient.d.ts

@@ -151,7 +151,7 @@ declare module '$app/navigation' {
 		opts?: { replaceState?: boolean; noscroll?: boolean; keepfocus?: boolean; state?: any }
 	): Promise<void>;
 	/**
-	 * Causes any `load` functions belonging to the currently active page to re-run if they `fetch` the resource in question, or re-fetches data from a page endpoint if the invalidated resource is the page itself. If no argument is given, all resources will be invalidated. Returns a `Promise` that resolves when the page is subsequently updated.
+	 * Causes any `load` functions belonging to the currently active page to re-run if they `fetch` the resource in question. If no argument is given, all resources will be invalidated. Returns a `Promise` that resolves when the page is subsequently updated.
 	 * @param dependency The invalidated resource
 	 */
 	export function invalidate(dependency?: string | ((href: string) => boolean)): Promise<void>;

package/types/index.d.ts

@@ -238,7 +238,7 @@ export interface ParamMatcher {
 export interface RequestEvent<
 	Params extends Partial<Record<string, string>> = Partial<Record<string, string>>
 > {
-	clientAddress: string;
+	getClientAddress: () => string;
 	locals: App.Locals;
 	params: Params;
 	platform: Readonly<App.Platform>;