@sveltejs/kit 2.15.2 → 2.16.0

package/src/exports/vite/index.js

@@ -15,9 +15,9 @@ import { build_server_nodes } from './build/build_server.js';
 import { build_service_worker } from './build/build_service_worker.js';
 import { assets_base, find_deps } from './build/utils.js';
 import { dev } from './dev/index.js';
-import { is_illegal, module_guard, normalize_id } from './graph_analysis/index.js';
+import { is_illegal, module_guard } from './graph_analysis/index.js';
 import { preview } from './preview/index.js';
-import { get_config_aliases, get_env, strip_virtual_prefix } from './utils.js';
+import { get_config_aliases, get_env, normalize_id, strip_virtual_prefix } from './utils.js';
 import { write_client_manifest } from '../../core/sync/write_client_manifest.js';
 import prerender from '../../core/postbuild/prerender.js';
 import analyse from '../../core/postbuild/analyse.js';
@@ -376,8 +376,14 @@ async function kit({ svelte_config }) {
 					parsed_importer.name === parsed_service_worker.name;
 
 				if (importer_is_service_worker && id !== '$service-worker' && id !== '$env/static/public') {
+					const normalized_cwd = vite.normalizePath(cwd);
+					const normalized_lib = vite.normalizePath(kit.files.lib);
 					throw new Error(
-						`Cannot import ${id} into service-worker code. Only the modules $service-worker and $env/static/public are available in service workers.`
+						`Cannot import ${normalize_id(
+							id,
+							normalized_lib,
+							normalized_cwd
+						)} into service-worker code. Only the modules $service-worker and $env/static/public are available in service workers.`
 					);
 				}
 
@@ -385,7 +391,11 @@ async function kit({ svelte_config }) {
 			}
 
 			// treat $env/static/[public|private] as virtual
-			if (id.startsWith('$env/') || id.startsWith('__sveltekit/') || id === '$service-worker') {
+			if (id.startsWith('$env/') || id === '$service-worker') {
+				// ids with :$ don't work with reverse proxies like nginx
+				return `\0virtual:${id.substring(1)}`;
+			}
+			if (id.startsWith('__sveltekit/')) {
 				return `\0virtual:${id}`;
 			}
 		},
@@ -649,7 +659,7 @@ async function kit({ svelte_config }) {
 								format: inline ? 'iife' : 'esm',
 								name: `__sveltekit_${version_hash}.app`,
 								entryFileNames: ssr ? '[name].js' : `${prefix}/[name].[hash].${ext}`,
-								chunkFileNames: ssr ? 'chunks/[name].js' : `${prefix}/chunks/[name].[hash].${ext}`,
+								chunkFileNames: ssr ? 'chunks/[name].js' : `${prefix}/chunks/[hash].${ext}`,
 								assetFileNames: `${prefix}/assets/[name].[hash][extname]`,
 								hoistTransitiveImports: false,
 								sourcemapIgnoreList,
@@ -666,7 +676,7 @@ async function kit({ svelte_config }) {
 						rollupOptions: {
 							output: {
 								entryFileNames: `${prefix}/workers/[name]-[hash].js`,
-								chunkFileNames: `${prefix}/workers/chunks/[name]-[hash].js`,
+								chunkFileNames: `${prefix}/workers/chunks/[hash].js`,
 								assetFileNames: `${prefix}/workers/assets/[name]-[hash][extname]`,
 								hoistTransitiveImports: false
 							}

package/src/exports/vite/module_ids.js

@@ -1,11 +1,11 @@
 import { fileURLToPath } from 'node:url';
 
-export const env_static_private = '\0virtual:$env/static/private';
-export const env_static_public = '\0virtual:$env/static/public';
-export const env_dynamic_private = '\0virtual:$env/dynamic/private';
-export const env_dynamic_public = '\0virtual:$env/dynamic/public';
+export const env_static_private = '\0virtual:env/static/private';
+export const env_static_public = '\0virtual:env/static/public';
+export const env_dynamic_private = '\0virtual:env/dynamic/private';
+export const env_dynamic_public = '\0virtual:env/dynamic/public';
 
-export const service_worker = '\0virtual:$service-worker';
+export const service_worker = '\0virtual:service-worker';
 
 export const sveltekit_environment = '\0virtual:__sveltekit/environment';
 export const sveltekit_paths = '\0virtual:__sveltekit/paths';

package/src/exports/vite/utils.js

@@ -4,6 +4,14 @@ import { posixify } from '../../utils/filesystem.js';
 import { negotiate } from '../../utils/http.js';
 import { filter_private_env, filter_public_env } from '../../utils/env.js';
 import { escape_html } from '../../utils/escape.js';
+import {
+	app_server,
+	env_dynamic_private,
+	env_dynamic_public,
+	env_static_private,
+	env_static_public,
+	service_worker
+} from './module_ids.js';
 
 /**
  * Transforms kit.alias to a valid vite.resolve.alias array.
@@ -105,4 +113,46 @@ export function not_found(req, res, base) {
 	}
 }
 
+/**
+ * Removes cwd/lib path from the start of the id
+ * @param {string} id
+ * @param {string} lib
+ * @param {string} cwd
+ */
+export function normalize_id(id, lib, cwd) {
+	if (id.startsWith(lib)) {
+		id = id.replace(lib, '$lib');
+	}
+
+	if (id.startsWith(cwd)) {
+		id = path.relative(cwd, id);
+	}
+
+	if (id === app_server) {
+		return '$app/server';
+	}
+
+	if (id === env_static_private) {
+		return '$env/static/private';
+	}
+
+	if (id === env_static_public) {
+		return '$env/static/public';
+	}
+
+	if (id === env_dynamic_private) {
+		return '$env/dynamic/private';
+	}
+
+	if (id === env_dynamic_public) {
+		return '$env/dynamic/public';
+	}
+
+	if (id === service_worker) {
+		return '$service-worker';
+	}
+
+	return posixify(id);
+}
+
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');

package/src/runtime/app/forms.js

@@ -65,6 +65,9 @@ function clone(element) {
  * - redirects to the nearest error page in case of an unexpected error
  *
  * If you provide a custom function with a callback and want to use the default behavior, invoke `update` in your callback.
+ * It accepts an options object
+ * - `reset: false` if you don't want the `<form>` values to be reset after a successful submission
+ * - `invalidateAll: false` if you don't want the action to call `invalidateAll` after submission
  * @template {Record<string, unknown> | undefined} Success
  * @template {Record<string, unknown> | undefined} Failure
  * @param {HTMLFormElement} form_element The form element

package/src/runtime/client/client.js

@@ -8,13 +8,7 @@ import {
 	make_trackable,
 	normalize_path
 } from '../../utils/url.js';
-import {
-	initial_fetch,
-	lock_fetch,
-	native_fetch,
-	subsequent_fetch,
-	unlock_fetch
-} from './fetcher.js';
+import { dev_fetch, initial_fetch, lock_fetch, subsequent_fetch, unlock_fetch } from './fetcher.js';
 import { parse } from './parse.js';
 import * as storage from './session-storage.js';
 import {
@@ -312,7 +306,9 @@ export async function start(_app, _target, hydrate) {
 	if (hydrate) {
 		await _hydrate(target, hydrate);
 	} else {
-		goto(location.href, { replaceState: true });
+		goto(app.hash ? decode_hash(new URL(location.href)) : location.href, {
+			replaceState: true
+		});
 	}
 
 	_start_router();
@@ -380,7 +376,7 @@ function persist_state() {
 
 /**
  * @param {string | URL} url
- * @param {{ replaceState?: boolean; noScroll?: boolean; keepFocus?: boolean; invalidateAll?: boolean; state?: Record<string, any> }} options
+ * @param {{ replaceState?: boolean; noScroll?: boolean; keepFocus?: boolean; invalidateAll?: boolean; invalidate?: Array<string | URL | ((url: URL) => boolean)>; state?: Record<string, any> }} options
  * @param {number} redirect_count
  * @param {{}} [nav_token]
  */
@@ -398,6 +394,10 @@ async function _goto(url, options, redirect_count, nav_token) {
 			if (options.invalidateAll) {
 				force_invalidation = true;
 			}
+
+			if (options.invalidate) {
+				options.invalidate.forEach(push_invalidated);
+			}
 		}
 	});
 }
@@ -428,9 +428,15 @@ async function _preload_data(intent) {
 	return load_cache.promise;
 }
 
-/** @param {URL} url */
+/**
+ * @param {URL} url
+ * @returns {Promise<void>}
+ */
 async function _preload_code(url) {
-	const route = routes.find((route) => route.exec(get_url_path(url)));
+	const rerouted = get_rerouted_url(url);
+	if (!rerouted) return;
+
+	const route = routes.find((route) => route.exec(get_url_path(rerouted)));
 
 	if (route) {
 		await Promise.all([...route.layouts, route.leaf].map((load) => load?.[1]()));
@@ -1153,45 +1159,49 @@ async function load_root_error_page({ status, error, url, route }) {
 		}
 	}
 
-	const root_layout = await load_node({
-		loader: default_layout_loader,
-		url,
-		params,
-		route,
-		parent: () => Promise.resolve({}),
-		server_data_node: create_data_node(server_data_node)
-	});
+	try {
+		const root_layout = await load_node({
+			loader: default_layout_loader,
+			url,
+			params,
+			route,
+			parent: () => Promise.resolve({}),
+			server_data_node: create_data_node(server_data_node)
+		});
 
-	/** @type {import('./types.js').BranchNode} */
-	const root_error = {
-		node: await default_error_loader(),
-		loader: default_error_loader,
-		universal: null,
-		server: null,
-		data: null
-	};
+		/** @type {import('./types.js').BranchNode} */
+		const root_error = {
+			node: await default_error_loader(),
+			loader: default_error_loader,
+			universal: null,
+			server: null,
+			data: null
+		};
 
-	return get_navigation_result_from_branch({
-		url,
-		params,
-		branch: [root_layout, root_error],
-		status,
-		error,
-		route: null
-	});
+		return get_navigation_result_from_branch({
+			url,
+			params,
+			branch: [root_layout, root_error],
+			status,
+			error,
+			route: null
+		});
+	} catch (error) {
+		if (error instanceof Redirect) {
+			return _goto(new URL(error.location, location.href), {}, 0);
+		}
+
+		// TODO: this falls back to the server when a server exists, but what about SPA mode?
+		throw error;
+	}
 }
 
 /**
- * Resolve the full info (which route, params, etc.) for a client-side navigation from the URL,
- * taking the reroute hook into account. If this isn't a client-side-navigation (or the URL is undefined),
- * returns undefined.
- * @param {URL | undefined} url
- * @param {boolean} invalidating
+ * Resolve the relative rerouted URL for a client-side navigation
+ * @param {URL} url
+ * @returns {URL | undefined}
  */
-function get_navigation_intent(url, invalidating) {
-	if (!url) return;
-	if (is_external_url(url, base, app.hash)) return;
-
+function get_rerouted_url(url) {
 	// reroute could alter the given URL, so we pass a copy
 	let rerouted;
 	try {
@@ -1218,9 +1228,26 @@ function get_navigation_intent(url, invalidating) {
 		}
 
 		// fall back to native navigation
-		return undefined;
+		return;
 	}
 
+	return rerouted;
+}
+
+/**
+ * Resolve the full info (which route, params, etc.) for a client-side navigation from the URL,
+ * taking the reroute hook into account. If this isn't a client-side-navigation (or the URL is undefined),
+ * returns undefined.
+ * @param {URL | undefined} url
+ * @param {boolean} invalidating
+ */
+function get_navigation_intent(url, invalidating) {
+	if (!url) return;
+	if (is_external_url(url, base, app.hash)) return;
+
+	const rerouted = get_rerouted_url(url);
+	if (!rerouted) return;
+
 	const path = get_url_path(rerouted);
 
 	for (const route of routes) {
@@ -1802,6 +1829,7 @@ export function disableScrollHandling() {
  * @param {boolean} [opts.noScroll] If `true`, the browser will maintain its scroll position rather than scrolling to the top of the page after navigation
  * @param {boolean} [opts.keepFocus] If `true`, the currently focused element will retain focus after navigation. Otherwise, focus will be reset to the body
  * @param {boolean} [opts.invalidateAll] If `true`, all `load` functions of the page will be rerun. See https://svelte.dev/docs/kit/load#rerunning-load-functions for more info on invalidation.
+ * @param {Array<string | URL | ((url: URL) => boolean)>} [opts.invalidate] Causes any load functions to re-run if they depend on one of the urls
  * @param {App.PageState} [opts.state] An optional object that will be available as `page.state`
  * @returns {Promise<void>}
  */
@@ -1848,14 +1876,21 @@ export function invalidate(resource) {
 		throw new Error('Cannot call invalidate(...) on the server');
 	}
 
+	push_invalidated(resource);
+
+	return _invalidate();
+}
+
+/**
+ * @param {string | URL | ((url: URL) => boolean)} resource The invalidated URL
+ */
+function push_invalidated(resource) {
 	if (typeof resource === 'function') {
 		invalidated.push(resource);
 	} else {
 		const { href } = new URL(resource, location.href);
 		invalidated.push((url) => url.href === href);
 	}
-
-	return _invalidate();
 }
 
 /**
@@ -1927,13 +1962,20 @@ export function preloadCode(pathname) {
 	const url = new URL(pathname, current.url);
 
 	if (DEV) {
+		if (!pathname.startsWith('/')) {
+			throw new Error(
+				'argument passed to preloadCode must be a pathname (i.e. "/about" rather than "http://example.com/about"'
+			);
+		}
+
 		if (!pathname.startsWith(base)) {
 			throw new Error(
-				`pathnames passed to preloadCode must start with \`paths.base\` (i.e. "${base}${pathname}" rather than "${pathname}")`
+				`pathname passed to preloadCode must start with \`paths.base\` (i.e. "${base}${pathname}" rather than "${pathname}")`
 			);
 		}
 
-		if (!routes.find((route) => route.exec(get_url_path(url)))) {
+		const rerouted = get_rerouted_url(url);
+		if (!rerouted || !routes.find((route) => route.exec(get_url_path(rerouted)))) {
 			throw new Error(`'${pathname}' did not match any routes`);
 		}
 	}
@@ -2321,7 +2363,7 @@ function _start_router() {
 			const state = event.state[STATES_KEY] ?? {};
 			const url = new URL(event.state[PAGE_URL_KEY] ?? location.href);
 			const navigation_index = event.state[NAVIGATION_INDEX];
-			const is_hash_change = strip_hash(location) === strip_hash(current.url);
+			const is_hash_change = current.url ? strip_hash(location) === strip_hash(current.url) : false;
 			const shallow =
 				navigation_index === current_navigation_index && (has_navigated || is_hash_change);
 
@@ -2392,7 +2434,7 @@ function _start_router() {
 			// (surprisingly!) mutates `current.url`, allowing us to
 			// detect it and trigger a navigation
 			if (current.url.hash === location.hash) {
-				navigate({ type: 'goto', url: current.url });
+				navigate({ type: 'goto', url: decode_hash(current.url) });
 			}
 		}
 	});
@@ -2539,7 +2581,9 @@ async function load_data(url, invalid) {
 	}
 	data_url.searchParams.append(INVALIDATED_PARAM, invalid.map((i) => (i ? '1' : '0')).join(''));
 
-	const res = await native_fetch(data_url.href);
+	// use window.fetch directly to allow using a 3rd party-patched fetch implementation
+	const fetcher = DEV ? dev_fetch : window.fetch;
+	const res = await fetcher(data_url.href, {});
 
 	if (!res.ok) {
 		// error message is a JSON-stringified string which devalue can't handle at the top level
@@ -2784,6 +2828,17 @@ function clone_page(page) {
 	};
 }
 
+/**
+ * @param {URL} url
+ * @returns {URL}
+ */
+function decode_hash(url) {
+	const new_url = new URL(url);
+	// Safari, for some reason, does change # to %23, when entered through the address bar
+	new_url.hash = decodeURIComponent(url.hash);
+	return new_url;
+}
+
 if (DEV) {
 	// Nasty hack to silence harmless warnings the user can do nothing about
 	const console_warn = console.warn;

package/src/runtime/client/fetcher.js

@@ -5,7 +5,7 @@ import { b64_decode } from '../utils.js';
 let loading = 0;
 
 /** @type {typeof fetch} */
-export const native_fetch = BROWSER ? window.fetch : /** @type {any} */ (() => {});
+const native_fetch = BROWSER ? window.fetch : /** @type {any} */ (() => {});
 
 export function lock_fetch() {
 	loading += 1;
@@ -137,7 +137,7 @@ export function subsequent_fetch(resource, resolved, opts) {
  * @param {RequestInfo | URL} resource
  * @param {RequestInit & Record<string, any> | undefined} opts
  */
-function dev_fetch(resource, opts) {
+export function dev_fetch(resource, opts) {
 	const patched_opts = { ...opts };
 	// This assigns the __sveltekit_fetch__ flag and makes it non-enumerable
 	Object.defineProperty(patched_opts, '__sveltekit_fetch__', {

package/src/runtime/client/utils.js

@@ -311,7 +311,7 @@ export function is_external_url(url, base, hash_routing) {
 	}
 
 	if (hash_routing) {
-		if (url.pathname === base + '/') {
+		if (url.pathname === base + '/' || url.pathname === base + '/index.html') {
 			return false;
 		}
 

package/src/runtime/server/cookie.js

@@ -55,7 +55,7 @@ export function get_cookies(request, url, trailing_slash) {
 
 		/**
 		 * @param {string} name
-		 * @param {import('cookie').CookieParseOptions} opts
+		 * @param {import('cookie').CookieParseOptions} [opts]
 		 */
 		get(name, opts) {
 			const c = new_cookies[name];
@@ -91,7 +91,7 @@ export function get_cookies(request, url, trailing_slash) {
 		},
 
 		/**
-		 * @param {import('cookie').CookieParseOptions} opts
+		 * @param {import('cookie').CookieParseOptions} [opts]
 		 */
 		getAll(opts) {
 			const cookies = parse(header, { decode: opts?.decode });

package/src/runtime/server/endpoint.js

@@ -1,3 +1,4 @@
+import { DEV } from 'esm-env';
 import { ENDPOINT_METHODS, PAGE_METHODS } from '../../constants.js';
 import { negotiate } from '../../utils/http.js';
 import { Redirect } from '../control.js';
@@ -10,6 +11,10 @@ import { method_not_allowed } from './utils.js';
  * @returns {Promise<Response>}
  */
 export async function render_endpoint(event, mod, state) {
+	if (DEV && event.request.headers.get('x-sveltekit-action') === 'true') {
+		throw new Error('use:enhance should only be used with SvelteKit form actions');
+	}
+
 	const method = /** @type {import('types').HttpMethod} */ (event.request.method);
 
 	let handler = mod[method] || mod.fallback;

package/src/runtime/server/respond.js

@@ -85,6 +85,21 @@ export async function respond(request, options, manifest, state) {
 		return text('Not found', { status: 404 });
 	}
 
+	const is_data_request = has_data_suffix(url.pathname);
+	/** @type {boolean[] | undefined} */
+	let invalidated_data_nodes;
+	if (is_data_request) {
+		url.pathname =
+			strip_data_suffix(url.pathname) +
+				(url.searchParams.get(TRAILING_SLASH_PARAM) === '1' ? '/' : '') || '/';
+		url.searchParams.delete(TRAILING_SLASH_PARAM);
+		invalidated_data_nodes = url.searchParams
+			.get(INVALIDATED_PARAM)
+			?.split('')
+			.map((node) => node === '1');
+		url.searchParams.delete(INVALIDATED_PARAM);
+	}
+
 	// reroute could alter the given URL, so we pass a copy
 	let rerouted_path;
 	try {
@@ -126,22 +141,6 @@ export async function respond(request, options, manifest, state) {
 		return text('Not found', { status: 404, headers });
 	}
 
-	const is_data_request = has_data_suffix(decoded);
-	/** @type {boolean[] | undefined} */
-	let invalidated_data_nodes;
-	if (is_data_request) {
-		decoded = strip_data_suffix(decoded) || '/';
-		url.pathname =
-			strip_data_suffix(url.pathname) +
-				(url.searchParams.get(TRAILING_SLASH_PARAM) === '1' ? '/' : '') || '/';
-		url.searchParams.delete(TRAILING_SLASH_PARAM);
-		invalidated_data_nodes = url.searchParams
-			.get(INVALIDATED_PARAM)
-			?.split('')
-			.map((node) => node === '1');
-		url.searchParams.delete(INVALIDATED_PARAM);
-	}
-
 	if (!state.prerendering?.fallback) {
 		// TODO this could theoretically break — should probably be inside a try-catch
 		const matchers = await manifest._.matchers();

package/src/utils/import.js

@@ -4,17 +4,22 @@ import { pathToFileURL } from 'node:url';
 
 /**
  * Resolve a dependency relative to the current working directory,
- * rather than relative to this package
+ * rather than relative to this package (but falls back to trying that, if necessary)
  * @param {string} dependency
  */
-export function resolve_peer_dependency(dependency) {
+export async function resolve_peer_dependency(dependency) {
 	try {
 		// @ts-expect-error the types are wrong
 		const resolved = imr.resolve(dependency, pathToFileURL(process.cwd() + '/dummy.js'));
-		return import(resolved);
+		return await import(resolved);
 	} catch {
-		throw new Error(
-			`Could not resolve peer dependency "${dependency}" relative to your project — please install it and try again.`
-		);
+		try {
+			// both imr.resolve and await import above can throw, which is why we can't just do import(resolved).catch(...) above
+			return await import(dependency);
+		} catch {
+			throw new Error(
+				`Could not resolve peer dependency "${dependency}" relative to your project — please install it and try again.`
+			);
+		}
 	}
 }

package/src/utils/routing.js

@@ -1,5 +1,4 @@
-// @ts-ignore - need to publish types for sub-package imports
-import BROWSER from 'esm-env/browser';
+import { BROWSER } from 'esm-env';
 
 const param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
 

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '2.15.2';
+export const VERSION = '2.16.0';