@sveltejs/kit 1.0.0-next.530 → 1.0.0-next.531

package/package.json

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

package/src/core/config/options.js

@@ -258,22 +258,39 @@ const options = object(
 				// TODO: remove this for the 1.0 release
 				force: validate(undefined, (input, keypath) => {
 					if (typeof input !== 'undefined') {
-						const newSetting = input ? 'continue' : 'fail';
-						const needsSetting = newSetting === 'continue';
+						const new_input = input ? 'warn' : 'fail';
+						const needs_option = new_input === 'warn';
 						throw new Error(
-							`${keypath} has been removed in favor of \`onError\`. In your case, set \`onError\` to "${newSetting}"${
-								needsSetting ? '' : ' (or leave it undefined)'
+							`${keypath} has been removed in favor of \`handleHttpError\`. In your case, set \`handleHttpError\` to "${new_input}"${
+								needs_option ? '' : ' (or leave it undefined)'
 							} to get the same behavior as you would with \`force: ${JSON.stringify(input)}\``
 						);
 					}
 				}),
 
-				onError: validate('fail', (input, keypath) => {
+				handleHttpError: validate('fail', (input, keypath) => {
 					if (typeof input === 'function') return input;
-					if (['continue', 'fail'].includes(input)) return input;
-					throw new Error(
-						`${keypath} should be either a custom function or one of "continue" or "fail"`
-					);
+					if (['fail', 'warn', 'ignore'].includes(input)) return input;
+					throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
+				}),
+
+				handleMissingId: validate('fail', (input, keypath) => {
+					if (typeof input === 'function') return input;
+					if (['fail', 'warn', 'ignore'].includes(input)) return input;
+					throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
+				}),
+
+				// TODO: remove this for the 1.0 release
+				onError: validate(undefined, (input, keypath) => {
+					if (typeof input !== 'undefined') {
+						let message = `${keypath} has been renamed to \`handleHttpError\``;
+
+						if (input === 'continue') {
+							message += ', and "continue" has been renamed to "warn"';
+						}
+
+						throw new Error(message);
+					}
 				}),
 
 				origin: validate('http://sveltekit-prerender', (input, keypath) => {

package/src/core/prerender/crawl.js

@@ -14,6 +14,9 @@ const WHITESPACE = /[\s\n\r]/;
 
 /** @param {string} html */
 export function crawl(html) {
+	/** @type {string[]} */
+	const ids = [];
+
 	/** @type {string[]} */
 	const hrefs = [];
 
@@ -125,7 +128,9 @@ export function crawl(html) {
 								let escaped = false;
 
 								while (i < html.length) {
-									if (!escaped) {
+									if (escaped) {
+										escaped = false;
+									} else {
 										const char = html[i];
 
 										if (html[i] === quote) {
@@ -153,6 +158,8 @@ export function crawl(html) {
 
 							if (name === 'href') {
 								href = value;
+							} else if (name === 'id') {
+								ids.push(value);
 							} else if (name === 'rel') {
 								rel = value;
 							} else if (name === 'src') {
@@ -194,5 +201,5 @@ export function crawl(html) {
 		i += 1;
 	}
 
-	return hrefs;
+	return { ids, hrefs };
 }

package/src/core/prerender/prerender.js

@@ -12,45 +12,31 @@ import { load_config } from '../config/index.js';
 import { get_route_segments } from '../../utils/routing.js';
 import { get_option } from '../../runtime/server/utils.js';
 
-/**
- * @typedef {import('types').PrerenderErrorHandler} PrerenderErrorHandler
- * @typedef {import('types').Logger} Logger
- */
-
 const [, , client_out_dir, results_path, verbose, env] = process.argv;
 
 prerender();
 
 /**
- * @param {Parameters<PrerenderErrorHandler>[0]} details
- * @param {import('types').ValidatedKitConfig} config
- */
-function format_error({ status, path, referrer, referenceType }, config) {
-	const message =
-		status === 404 && !path.startsWith(config.paths.base)
-			? `${path} does not begin with \`base\`, which is configured in \`paths.base\` and can be imported from \`$app/paths\` - see https://kit.svelte.dev/docs/configuration#paths for more info`
-			: path;
-
-	return `${status} ${message}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
-}
-
-/**
- * @param {Logger} log
- * @param {import('types').ValidatedKitConfig} config
- * @returns {PrerenderErrorHandler}
+ * @template T
+ * @param {import('types').Logger} log
+ * @param {'fail' | 'warn' | 'ignore' | ((details: T) => void)} input
+ * @param {(details: T) => string} format
+ * @returns {(details: T) => void}
  */
-function normalise_error_handler(log, config) {
-	switch (config.prerender.onError) {
-		case 'continue':
+function normalise_error_handler(log, input, format) {
+	switch (input) {
+		case 'fail':
 			return (details) => {
-				log.error(format_error(details, config));
+				throw new Error(format(details));
 			};
-		case 'fail':
+		case 'warn':
 			return (details) => {
-				throw new Error(format_error(details, config));
+				log.error(format(details));
 			};
+		case 'ignore':
+			return () => {};
 		default:
-			return config.prerender.onError;
+			return (details) => input({ ...details, message: format(details) });
 	}
 }
 
@@ -133,7 +119,29 @@ export async function prerender() {
 	const server = new Server(manifest);
 	await server.init({ env: JSON.parse(env) });
 
-	const error = normalise_error_handler(log, config);
+	const handle_http_error = normalise_error_handler(
+		log,
+		config.prerender.handleHttpError,
+		({ status, path, referrer, referenceType }) => {
+			const message =
+				status === 404 && !path.startsWith(config.paths.base)
+					? `${path} does not begin with \`base\`, which is configured in \`paths.base\` and can be imported from \`$app/paths\` - see https://kit.svelte.dev/docs/configuration#paths for more info`
+					: path;
+
+			return `${status} ${message}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
+		}
+	);
+
+	const handle_missing_id = normalise_error_handler(
+		log,
+		config.prerender.handleMissingId,
+		({ path, id, referrers }) => {
+			return (
+				`The following pages contain links to ${path}#${id}, but no element with id="${id}" exists on ${path}:` +
+				referrers.map((l) => `\n  - ${l}`).join('')
+			);
+		}
+	);
 
 	const q = queue(config.prerender.concurrency);
 
@@ -155,6 +163,12 @@ export async function prerender() {
 	const seen = new Set();
 	const written = new Set();
 
+	/** @type {Map<string, Set<string>>} */
+	const expected_hashlinks = new Map();
+
+	/** @type {Map<string, string[]>} */
+	const actual_hashlinks = new Map();
+
 	/**
 	 * @param {string | null} referrer
 	 * @param {string} decoded
@@ -177,7 +191,7 @@ export async function prerender() {
 	 */
 	async function visit(decoded, encoded, referrer) {
 		if (!decoded.startsWith(config.paths.base)) {
-			error({ status: 404, path: decoded, referrer, referenceType: 'linked' });
+			handle_http_error({ status: 404, path: decoded, referrer, referenceType: 'linked' });
 			return;
 		}
 
@@ -231,18 +245,30 @@ export async function prerender() {
 		const headers = Object.fromEntries(response.headers);
 
 		if (config.prerender.crawl && headers['content-type'] === 'text/html') {
-			for (const href of crawl(body.toString())) {
-				if (href.startsWith('data:') || href.startsWith('#')) continue;
+			const { ids, hrefs } = crawl(body.toString());
+
+			actual_hashlinks.set(decoded, ids);
+
+			for (const href of hrefs) {
+				if (href.startsWith('data:')) continue;
 
 				const resolved = resolve(encoded, href);
 				if (!is_root_relative(resolved)) continue;
 
-				const { pathname, search } = new URL(resolved, 'http://localhost');
+				const { pathname, search, hash } = new URL(resolved, 'http://localhost');
 
 				if (search) {
 					// TODO warn that query strings have no effect on statically-exported pages
 				}
 
+				if (hash) {
+					if (!expected_hashlinks.has(pathname + hash)) {
+						expected_hashlinks.set(pathname + hash, new Set());
+					}
+
+					/** @type {Set<string>} */ (expected_hashlinks.get(pathname + hash)).add(decoded);
+				}
+
 				enqueue(decoded, decodeURI(pathname), pathname);
 			}
 		}
@@ -329,7 +355,7 @@ export async function prerender() {
 
 			prerendered.paths.push(decoded);
 		} else if (response_type !== OK) {
-			error({ status: response.status, path: decoded, referrer, referenceType });
+			handle_http_error({ status: response.status, path: decoded, referrer, referenceType });
 		}
 	}
 
@@ -381,6 +407,20 @@ export async function prerender() {
 
 	await q.done();
 
+	// handle invalid fragment links
+	for (const [key, referrers] of expected_hashlinks) {
+		const index = key.indexOf('#');
+		const path = key.slice(0, index);
+		const id = key.slice(index + 1);
+
+		// ignore fragment links to pages that were not prerendered
+		if (!actual_hashlinks.has(path)) continue;
+
+		if (!actual_hashlinks.get(path).includes(id)) {
+			handle_missing_id({ id, path, referrers: Array.from(referrers) });
+		}
+	}
+
 	/** @type {string[]} */
 	const not_prerendered = [];
 

package/src/utils/url.js

@@ -7,6 +7,7 @@ const scheme = /^[a-z]+:/;
  */
 export function resolve(base, path) {
 	if (scheme.test(path)) return path;
+	if (path[0] === '#') return base + path;
 
 	const base_match = absolute.exec(base);
 	const path_match = absolute.exec(path);

package/types/index.d.ts

@@ -10,7 +10,8 @@ import {
 	Logger,
 	MaybePromise,
 	Prerendered,
-	PrerenderOnErrorValue,
+	PrerenderHttpErrorHandlerValue,
+	PrerenderMissingIdHandlerValue,
 	RequestOptions,
 	RouteDefinition,
 	TrailingSlash,
@@ -222,7 +223,8 @@ export interface KitConfig {
 		default?: boolean;
 		enabled?: boolean;
 		entries?: Array<'*' | `/${string}`>;
-		onError?: PrerenderOnErrorValue;
+		handleHttpError?: PrerenderHttpErrorHandlerValue;
+		handleMissingId?: PrerenderMissingIdHandlerValue;
 		origin?: string;
 	};
 	serviceWorker?: {

package/types/private.d.ts

@@ -179,7 +179,7 @@ export interface Prerendered {
 	paths: string[];
 }
 
-export interface PrerenderErrorHandler {
+export interface PrerenderHttpErrorHandler {
 	(details: {
 		status: number;
 		path: string;
@@ -188,7 +188,12 @@ export interface PrerenderErrorHandler {
 	}): void;
 }
 
-export type PrerenderOnErrorValue = 'fail' | 'continue' | PrerenderErrorHandler;
+export interface PrerenderMissingIdHandler {
+	(details: { path: string; id: string; referrers: string[] }): void;
+}
+
+export type PrerenderHttpErrorHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderHttpErrorHandler;
+export type PrerenderMissingIdHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderMissingIdHandler;
 
 export type PrerenderOption = boolean | 'auto';