@sveltejs/kit 1.0.0-next.266 → 1.0.0-next.267

package/assets/client/start.js

@@ -6,6 +6,22 @@ import { writable } from 'svelte/store';
 import { base, set_paths } from '../paths.js';
 import { init } from './singletons.js';
 
+/**
+ * @param {string} path
+ * @param {'always' | 'never' | 'ignore'} trailing_slash
+ */
+function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && /\/[^./]+$/.test(path)) {
+		return path + '/';
+	}
+
+	return path;
+}
+
 function scroll_state() {
 	return {
 		x: pageXOffset,
@@ -396,14 +412,7 @@ class Router {
 		}
 		this.navigating++;
 
-		let { pathname } = url;
-
-		if (this.trailing_slash === 'never') {
-			if (pathname !== '/' && pathname.endsWith('/')) pathname = pathname.slice(0, -1);
-		} else if (this.trailing_slash === 'always') {
-			const is_file = /** @type {string} */ (url.pathname.split('/').pop()).includes('.');
-			if (!is_file && !pathname.endsWith('/')) pathname += '/';
-		}
+		const pathname = normalize_path(url.pathname, this.trailing_slash);
 
 		info.url = new URL(url.origin + pathname + url.search + url.hash);
 

package/assets/server/index.js

@@ -1498,6 +1498,22 @@ function is_root_relative(path) {
 	return path[0] === '/' && path[1] !== '/';
 }
 
+/**
+ * @param {string} path
+ * @param {'always' | 'never' | 'ignore'} trailing_slash
+ */
+function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && /\/[^./]+$/.test(path)) {
+		return path + '/';
+	}
+
+	return path;
+}
+
 /**
  * @param {{
  *   event: import('types/hooks').RequestEvent;
@@ -1700,9 +1716,7 @@ async function load_node({
 				} else {
 					// external
 					if (resolved.startsWith('//')) {
-						throw new Error(
-							`Cannot request protocol-relative URL (${requested}) in server-side fetch`
-						);
+						requested = event.url.protocol + requested;
 					}
 
 					// external fetch
@@ -1889,22 +1903,21 @@ async function load_shadow_data(route, event, prerender) {
 			if (result.fallthrough) return result;
 
 			const { status, headers, body } = validate_shadow_output(result);
+			data.status = status;
+
 			add_cookies(/** @type {string[]} */ (data.cookies), headers);
 
 			// Redirects are respected...
 			if (status >= 300 && status < 400) {
-				return {
-					status,
-					redirect: /** @type {string} */ (
-						headers instanceof Headers ? headers.get('location') : headers.location
-					)
-				};
+				data.redirect = /** @type {string} */ (
+					headers instanceof Headers ? headers.get('location') : headers.location
+				);
+				return data;
 			}
 
 			// ...but 4xx and 5xx status codes _don't_ result in the error page
 			// rendering for non-GET requests — instead, we allow the page
 			// to render with any validation errors etc that were returned
-			data.status = status;
 			data.body = body;
 		}
 
@@ -1915,21 +1928,18 @@ async function load_shadow_data(route, event, prerender) {
 
 			const { status, headers, body } = validate_shadow_output(result);
 			add_cookies(/** @type {string[]} */ (data.cookies), headers);
+			data.status = status;
 
 			if (status >= 400) {
-				return {
-					status,
-					error: new Error('Failed to load data')
-				};
+				data.error = new Error('Failed to load data');
+				return data;
 			}
 
 			if (status >= 300) {
-				return {
-					status,
-					redirect: /** @type {string} */ (
-						headers instanceof Headers ? headers.get('location') : headers.location
-					)
-				};
+				data.redirect = /** @type {string} */ (
+					headers instanceof Headers ? headers.get('location') : headers.location
+				);
+				return data;
 			}
 
 			data.body = { ...body, ...data.body };
@@ -2448,26 +2458,15 @@ const DATA_SUFFIX = '/__data.json';
 async function respond(request, options, state = {}) {
 	const url = new URL(request.url);
 
-	if (url.pathname !== '/' && options.trailing_slash !== 'ignore') {
-		const has_trailing_slash = url.pathname.endsWith('/');
+	const normalized = normalize_path(url.pathname, options.trailing_slash);
 
-		if (
-			(has_trailing_slash && options.trailing_slash === 'never') ||
-			(!has_trailing_slash &&
-				options.trailing_slash === 'always' &&
-				!(url.pathname.split('/').pop() || '').includes('.'))
-		) {
-			url.pathname = has_trailing_slash ? url.pathname.slice(0, -1) : url.pathname + '/';
-
-			if (url.search === '?') url.search = '';
-
-			return new Response(undefined, {
-				status: 301,
-				headers: {
-					location: url.pathname + url.search
-				}
-			});
-		}
+	if (normalized !== url.pathname) {
+		return new Response(undefined, {
+			status: 301,
+			headers: {
+				location: normalized + (url.search === '?' ? '' : url.search)
+			}
+		});
 	}
 
 	const { parameter, allowed } = options.method_override;
@@ -2596,11 +2595,11 @@ async function respond(request, options, state = {}) {
 							const location = response.headers.get('location');
 
 							if (location) {
+								const headers = new Headers(response.headers);
+								headers.set('x-sveltekit-location', location);
 								response = new Response(undefined, {
 									status: 204,
-									headers: {
-										'x-sveltekit-location': location
-									}
+									headers
 								});
 							}
 						}

package/dist/chunks/index5.js

@@ -1,4 +1,4 @@
-import { m as mkdirp, b as SVELTE_KIT, h as rimraf, i as copy, $, j as logger } from '../cli.js';
+import { b as SVELTE_KIT, m as mkdirp, h as rimraf, i as copy, $, j as logger } from '../cli.js';
 import { readFileSync, writeFileSync } from 'fs';
 import { resolve as resolve$1, join, dirname } from 'path';
 import { pathToFileURL, URL } from 'url';
@@ -55,6 +55,22 @@ function is_root_relative(path) {
 	return path[0] === '/' && path[1] !== '/';
 }
 
+/**
+ * @param {string} path
+ * @param {'always' | 'never' | 'ignore'} trailing_slash
+ */
+function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && /\/[^./]+$/.test(path)) {
+		return path + '/';
+	}
+
+	return path;
+}
+
 /** @typedef {{
  *   fn: () => Promise<any>,
  *   fulfil: (value: any) => void,
@@ -425,25 +441,27 @@ const REDIRECT = 3;
  *   fallback?: string;
  *   all: boolean; // disregard `export const prerender = true`
  * }} opts
- * @returns {Promise<{ paths: string[] }>} returns a promise that resolves to an array of paths corresponding to the files that have been prerendered.
  */
 async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
+	/** @type {import('types/config').Prerendered} */
+	const prerendered = {
+		pages: new Map(),
+		assets: new Map(),
+		redirects: new Map(),
+		paths: []
+	};
+
 	if (!config.kit.prerender.enabled && !fallback) {
-		return { paths: [] };
+		return prerendered;
 	}
 
 	__fetch_polyfill();
 
-	mkdirp(out);
-
-	const dir = resolve$1(cwd, `${SVELTE_KIT}/output`);
-
-	const seen = new Set();
-
-	const server_root = resolve$1(dir);
+	const server_root = resolve$1(cwd, `${SVELTE_KIT}/output`);
 
 	/** @type {import('types/internal').AppModule} */
 	const { App, override } = await import(pathToFileURL(`${server_root}/server/app.js`).href);
+	const { manifest } = await import(pathToFileURL(`${server_root}/server/manifest.js`).href);
 
 	override({
 		paths: config.kit.paths,
@@ -451,8 +469,6 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 		read: (file) => readFileSync(join(config.kit.files.assets, file))
 	});
 
-	const { manifest } = await import(pathToFileURL(`${server_root}/server/manifest.js`).href);
-
 	const app = new App(manifest);
 
 	const error = normalise_error_handler(log, config.kit.prerender.onError);
@@ -463,28 +479,12 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 		...build_data.client.assets.map((chunk) => `${config.kit.appDir}/${chunk.fileName}`)
 	]);
 
-	/** @type {string[]} */
-	const paths = [];
-
 	build_data.static.forEach((file) => {
 		if (file.endsWith('/index.html')) {
 			files.add(file.slice(0, -11));
 		}
 	});
 
-	/**
-	 * @param {string} path
-	 */
-	function normalize(path) {
-		if (config.kit.trailingSlash === 'always') {
-			return path.endsWith('/') ? path : `${path}/`;
-		} else if (config.kit.trailingSlash === 'never') {
-			return !path.endsWith('/') || path === '/' ? path : path.slice(0, -1);
-		}
-
-		return path;
-	}
-
 	const q = queue(config.kit.prerender.concurrency);
 
 	/**
@@ -492,150 +492,168 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 	 * @param {boolean} is_html
 	 */
 	function output_filename(path, is_html) {
-		path = path.slice(config.kit.paths.base.length) || '/';
+		const file = path.slice(config.kit.paths.base.length + 1);
 
-		if (path === '/') {
-			return '/index.html';
+		if (file === '') {
+			return 'index.html';
 		}
 
-		const parts = path.split('/');
-		if (is_html && parts[parts.length - 1] !== 'index.html') {
-			if (config.kit.trailingSlash === 'always') {
-				parts.push('index.html');
-			} else {
-				parts[parts.length - 1] += '.html';
-			}
+		if (is_html && !file.endsWith('.html')) {
+			return file + (config.kit.trailingSlash === 'always' ? 'index.html' : '.html');
 		}
-		return parts.join('/');
+
+		return file;
 	}
 
+	const seen = new Set();
+	const written = new Set();
+
 	/**
-	 * @param {string} decoded_path
-	 * @param {string?} referrer
+	 * @param {string | null} referrer
+	 * @param {string} decoded
+	 * @param {string} [encoded]
 	 */
-	function enqueue(decoded_path, referrer) {
-		const path = encodeURI(normalize(decoded_path));
+	function enqueue(referrer, decoded, encoded) {
+		if (seen.has(decoded)) return;
+		seen.add(decoded);
 
-		if (seen.has(path)) return;
-		seen.add(path);
+		const file = decoded.slice(config.kit.paths.base.length + 1);
+		if (files.has(file)) return;
 
-		return q.add(() => visit(path, decoded_path, referrer));
+		return q.add(() => visit(decoded, encoded || encodeURI(decoded), referrer));
 	}
 
 	/**
-	 * @param {string} path
-	 * @param {string} decoded_path
+	 * @param {string} decoded
+	 * @param {string} encoded
 	 * @param {string?} referrer
 	 */
-	async function visit(path, decoded_path, referrer) {
-		if (!path.startsWith(config.kit.paths.base)) {
-			error({ status: 404, path, referrer, referenceType: 'linked' });
+	async function visit(decoded, encoded, referrer) {
+		if (!decoded.startsWith(config.kit.paths.base)) {
+			error({ status: 404, path: decoded, referrer, referenceType: 'linked' });
 			return;
 		}
 
 		/** @type {Map<string, import('types/internal').PrerenderDependency>} */
 		const dependencies = new Map();
 
-		const rendered = await app.render(new Request(`http://sveltekit-prerender${path}`), {
+		const response = await app.render(new Request(`http://sveltekit-prerender${encoded}`), {
 			prerender: {
 				all,
 				dependencies
 			}
 		});
 
-		const response_type = Math.floor(rendered.status / 100);
-		const type = rendered.headers.get('content-type');
+		const text = await response.text();
+
+		save(response, text, decoded, encoded, referrer, 'linked');
+
+		for (const [dependency_path, result] of dependencies) {
+			// this seems circuitous, but using new URL allows us to not care
+			// whether dependency_path is encoded or not
+			const encoded_dependency_path = new URL(dependency_path, 'http://localhost').pathname;
+			const decoded_dependency_path = decodeURI(encoded_dependency_path);
+
+			const body = result.body ?? new Uint8Array(await result.response.arrayBuffer());
+			save(
+				result.response,
+				body,
+				decoded_dependency_path,
+				encoded_dependency_path,
+				decoded,
+				'fetched'
+			);
+		}
+
+		if (config.kit.prerender.crawl && response.headers.get('content-type') === 'text/html') {
+			for (const href of crawl(text)) {
+				if (href.startsWith('data:') || href.startsWith('#')) continue;
+
+				const resolved = resolve(encoded, href);
+				if (!is_root_relative(resolved)) continue;
+
+				const parsed = new URL(resolved, 'http://localhost');
+
+				if (parsed.search) ;
+
+				const pathname = normalize_path(parsed.pathname, config.kit.trailingSlash);
+				enqueue(decoded, decodeURI(pathname), pathname);
+			}
+		}
+	}
+
+	/**
+	 * @param {Response} response
+	 * @param {string | Uint8Array} body
+	 * @param {string} decoded
+	 * @param {string} encoded
+	 * @param {string | null} referrer
+	 * @param {'linked' | 'fetched'} referenceType
+	 */
+	function save(response, body, decoded, encoded, referrer, referenceType) {
+		const response_type = Math.floor(response.status / 100);
+		const type = /** @type {string} */ (response.headers.get('content-type'));
 		const is_html = response_type === REDIRECT || type === 'text/html';
 
-		const file = `${out}${output_filename(decoded_path, is_html)}`;
+		const file = output_filename(decoded, is_html);
+		const dest = `${out}/${file}`;
+
+		if (written.has(file)) return;
+		written.add(file);
 
 		if (response_type === REDIRECT) {
-			const location = rendered.headers.get('location');
+			const location = response.headers.get('location');
 
 			if (location) {
-				mkdirp(dirname(file));
+				mkdirp(dirname(dest));
 
-				log.warn(`${rendered.status} ${decoded_path} -> ${location}`);
+				log.warn(`${response.status} ${decoded} -> ${location}`);
 
 				writeFileSync(
-					file,
+					dest,
 					`<meta http-equiv="refresh" content=${escape_html_attr(`0;url=${location}`)}>`
 				);
 
-				const resolved = resolve(path, location);
+				let resolved = resolve(encoded, location);
 				if (is_root_relative(resolved)) {
-					enqueue(resolved, path);
+					resolved = normalize_path(resolved, config.kit.trailingSlash);
+					enqueue(decoded, decodeURI(resolved), resolved);
+				}
+
+				if (!prerendered.redirects.has(decoded)) {
+					prerendered.redirects.set(decoded, {
+						status: response.status,
+						location: resolved
+					});
+
+					prerendered.paths.push(normalize_path(decoded, 'never'));
 				}
 			} else {
-				log.warn(`location header missing on redirect received from ${decoded_path}`);
+				log.warn(`location header missing on redirect received from ${decoded}`);
 			}
 
 			return;
 		}
 
-		const text = await rendered.text();
-
-		if (rendered.status === 200) {
-			mkdirp(dirname(file));
-
-			log.info(`${rendered.status} ${decoded_path}`);
-			writeFileSync(file, text);
-			paths.push(normalize(decoded_path));
-		} else if (response_type !== OK) {
-			error({ status: rendered.status, path, referrer, referenceType: 'linked' });
-		}
+		if (response.status === 200) {
+			mkdirp(dirname(dest));
 
-		for (const [dependency_path, result] of dependencies) {
-			const { status, headers } = result.response;
-
-			const response_type = Math.floor(status / 100);
-
-			const is_html = headers.get('content-type') === 'text/html';
-
-			const file = `${out}${output_filename(dependency_path, is_html)}`;
-			mkdirp(dirname(file));
-
-			writeFileSync(
-				file,
-				result.body === null ? new Uint8Array(await result.response.arrayBuffer()) : result.body
-			);
-			paths.push(dependency_path);
+			log.info(`${response.status} ${decoded}`);
+			writeFileSync(dest, body);
 
-			if (response_type === OK) {
-				log.info(`${status} ${dependency_path}`);
+			if (is_html) {
+				prerendered.pages.set(decoded, {
+					file
+				});
 			} else {
-				error({
-					status,
-					path: dependency_path,
-					referrer: path,
-					referenceType: 'fetched'
+				prerendered.assets.set(decoded, {
+					type
 				});
 			}
-		}
-
-		if (is_html && config.kit.prerender.crawl) {
-			for (const href of crawl(text)) {
-				if (href.startsWith('data:') || href.startsWith('#')) continue;
-
-				const resolved = resolve(path, href);
-				if (!is_root_relative(resolved)) continue;
-
-				const parsed = new URL(resolved, 'http://localhost');
-
-				let pathname = decodeURI(parsed.pathname);
-
-				if (config.kit.paths.base) {
-					if (!pathname.startsWith(config.kit.paths.base)) continue;
-					pathname = pathname.slice(config.kit.paths.base.length) || '/';
-				}
-
-				const file = pathname.slice(1);
-				if (files.has(file)) continue;
-
-				if (parsed.search) ;
 
-				enqueue(pathname, path);
-			}
+			prerendered.paths.push(normalize_path(decoded, 'never'));
+		} else if (response_type !== OK) {
+			error({ status: response.status, path: decoded, referrer, referenceType });
 		}
 	}
 
@@ -643,10 +661,10 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 		for (const entry of config.kit.prerender.entries) {
 			if (entry === '*') {
 				for (const entry of build_data.entries) {
-					enqueue(config.kit.paths.base + entry, null);
+					enqueue(null, normalize_path(config.kit.paths.base + entry, config.kit.trailingSlash)); // TODO can we pre-normalize these?
 				}
 			} else {
-				enqueue(config.kit.paths.base + entry, null);
+				enqueue(null, normalize_path(config.kit.paths.base + entry, config.kit.trailingSlash));
 			}
 		}
 
@@ -667,9 +685,7 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
 		writeFileSync(file, await rendered.text());
 	}
 
-	return {
-		paths
-	};
+	return prerendered;
 }
 
 /**
@@ -683,11 +699,14 @@ async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
  */
 function create_builder({ cwd, config, build_data, log }) {
 	/** @type {Set<string>} */
-	const prerendered_paths = new Set();
+	let prerendered_paths;
+
 	let generated_manifest = false;
 
 	/** @param {import('types/internal').RouteData} route */
 	function not_prerendered(route) {
+		if (!prerendered_paths) return true;
+
 		if (route.type === 'page' && route.path) {
 			return !prerendered_paths.has(route.path);
 		}
@@ -832,10 +851,7 @@ function create_builder({ cwd, config, build_data, log }) {
 				log
 			});
 
-			prerendered.paths.forEach((path) => {
-				prerendered_paths.add(path);
-				prerendered_paths.add(path + '/');
-			});
+			prerendered_paths = new Set(prerendered.paths);
 
 			return prerendered;
 		}

package/dist/cli.js

@@ -998,7 +998,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.266');
+const prog = sade('svelte-kit').version('1.0.0-next.267');
 
 prog
 	.command('dev')
@@ -1156,7 +1156,7 @@ async function check_port(port) {
 function welcome({ port, host, https, open, loose, allow, cwd }) {
 	if (open) launch(port, https);
 
-	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.266'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.267'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.266",
+  "version": "1.0.0-next.267",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/types/config.d.ts

@@ -35,6 +35,32 @@ export interface AdapterEntry {
 	}) => void;
 }
 
+export interface Prerendered {
+	pages: Map<
+		string,
+		{
+			/** The location of the .html file relative to the output directory */
+			file: string;
+		}
+	>;
+	assets: Map<
+		string,
+		{
+			/** The MIME type of the asset */
+			type: string;
+		}
+	>;
+	redirects: Map<
+		string,
+		{
+			status: number;
+			location: string;
+		}
+	>;
+	/** An array of prerendered paths (without trailing slashes, regardless of the trailingSlash config) */
+	paths: string[];
+}
+
 export interface Builder {
 	log: Logger;
 	rimraf(dir: string): void;
@@ -87,9 +113,7 @@ export interface Builder {
 		}
 	): string[];
 
-	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<{
-		paths: string[];
-	}>;
+	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<Prerendered>;
 }
 
 export interface Adapter {

package/types/index.d.ts

@@ -4,7 +4,14 @@
 import './ambient-modules';
 
 export { App, SSRManifest } from './app';
-export { Adapter, Builder, Config, PrerenderErrorHandler, ValidatedConfig } from './config';
+export {
+	Adapter,
+	Builder,
+	Config,
+	Prerendered,
+	PrerenderErrorHandler,
+	ValidatedConfig
+} from './config';
 export { EndpointOutput, RequestHandler } from './endpoint';
 export { ErrorLoad, ErrorLoadInput, Load, LoadInput, LoadOutput } from './page';
 export { ExternalFetch, GetSession, Handle, HandleError, RequestEvent, ResolveOpts } from './hooks';