@sveltejs/kit 3.0.0-next.1 → 3.0.0-next.11

package/src/exports/vite/module_ids.js

@@ -9,8 +9,6 @@ export const sveltekit_env_service_worker = '\0virtual:__sveltekit/env/service-w
 
 export const service_worker = '\0virtual:service-worker';
 
-export const sveltekit_server = '\0virtual:__sveltekit/server';
-
 export const app_server = posixify(
 	fileURLToPath(new URL('../../runtime/app/server/index.js', import.meta.url))
 );

package/src/exports/vite/preview/index.js

@@ -1,24 +1,23 @@
+/** @import { NextHandleFunction } from 'connect' */
+/** @import { PreviewServer, ResolvedConfig } from 'vite' */
+/** @import { ValidatedConfig, ServerInternalModule, ServerModule } from 'types' */
 import fs from 'node:fs';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { lookup } from 'mrmime';
+import { lookup } from '../../../utils/mime.js';
 import sirv from 'sirv';
 import { loadEnv, normalizePath } from 'vite';
 import { createReadableStream, getRequest, setResponse } from '../../../exports/node/index.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { is_chrome_devtools_request, not_found } from '../utils.js';
-
-/** @typedef {import('http').IncomingMessage} Req */
-/** @typedef {import('http').ServerResponse} Res */
-/** @typedef {(req: Req, res: Res, next: () => void) => void} Handler */
+import { stackless } from '../../../utils/error.js';
 
 /**
- * @param {import('vite').PreviewServer} vite
- * @param {import('vite').ResolvedConfig} vite_config
- * @param {import('types').ValidatedConfig} svelte_config
- * @param {import('@sveltejs/kit').Adapter | undefined} adapter
+ * @param {PreviewServer} vite
+ * @param {ResolvedConfig} vite_config
+ * @param {ValidatedConfig} svelte_config
  */
-export async function preview(vite, vite_config, svelte_config, adapter) {
+export async function preview(vite, vite_config, svelte_config) {
 	const { paths } = svelte_config.kit;
 	const base = paths.base;
 	const assets = paths.assets ? SVELTE_KIT_ASSETS : paths.base;
@@ -29,8 +28,8 @@ export async function preview(vite, vite_config, svelte_config, adapter) {
 
 	const dir = join(svelte_config.kit.outDir, 'output/server');
 
-	if (!fs.existsSync(dir)) {
-		throw new Error(`Server files not found at ${dir}, did you run \`build\` first?`);
+	if (!fs.existsSync(`${dir}/manifest.js`)) {
+		throw stackless(`Server files not found at ${dir}, did you run \`build\` first?`);
 	}
 
 	const instrumentation = join(dir, 'instrumentation.server.js');
@@ -38,10 +37,10 @@ export async function preview(vite, vite_config, svelte_config, adapter) {
 		await import(pathToFileURL(instrumentation).href);
 	}
 
-	/** @type {import('types').ServerInternalModule} */
+	/** @type {ServerInternalModule} */
 	const { set_assets } = await import(pathToFileURL(join(dir, 'internal.js')).href);
 
-	/** @type {import('types').ServerModule} */
+	/** @type {ServerModule} */
 	const { Server } = await import(pathToFileURL(join(dir, 'index.js')).href);
 
 	const { manifest } = await import(pathToFileURL(join(dir, 'manifest.js')).href);
@@ -49,12 +48,21 @@ export async function preview(vite, vite_config, svelte_config, adapter) {
 	set_assets(assets);
 
 	const server = new Server(manifest);
-	await server.init({
-		env: loadEnv(vite_config.mode, svelte_config.kit.env.dir, ''),
-		read: (file) => createReadableStream(`${dir}/${file}`)
-	});
 
-	const emulator = await adapter?.emulate?.();
+	try {
+		await server.init({
+			env: loadEnv(vite_config.mode, svelte_config.kit.env.dir, ''),
+			read: (file) => createReadableStream(`${dir}/${file}`)
+		});
+	} catch (error) {
+		// Vite erases the error message when starting the preview server so we store
+		// it in the stack instead. This ensures errors thrown using `stackless`
+		// are still readable
+		if (error instanceof Error) error.stack = error.message;
+		throw error;
+	}
+
+	const emulator = await svelte_config.kit.adapter?.emulate?.();
 
 	return () => {
 		// Remove the base middleware. It screws with the URL.
@@ -196,12 +204,12 @@ export async function preview(vite, vite_config, svelte_config, adapter) {
 		vite.middlewares.use(async (req, res) => {
 			const host = req.headers[':authority'] || req.headers.host;
 
-			const request = await getRequest({
+			const request = getRequest({
 				base: `${protocol}://${host}`,
 				request: req
 			});
 
-			await setResponse(
+			setResponse(
 				res,
 				await server.respond(request, {
 					getClientAddress: () => {
@@ -225,7 +233,7 @@ export async function preview(vite, vite_config, svelte_config, adapter) {
 
 /**
  * @param {string} dir
- * @returns {Handler}
+ * @returns {NextHandleFunction}
  */
 const mutable = (dir) =>
 	fs.existsSync(dir)
@@ -237,8 +245,8 @@ const mutable = (dir) =>
 
 /**
  * @param {string} scope
- * @param {Handler} handler
- * @returns {Handler}
+ * @param {NextHandleFunction} handler
+ * @returns {NextHandleFunction}
  */
 function scoped(scope, handler) {
 	if (scope === '') return handler;

package/src/exports/vite/static_analysis/index.js

@@ -1,9 +1,10 @@
+/** @import { PageOptions } from './types.js' */
 import path from 'node:path';
 import { tsPlugin } from '@sveltejs/acorn-typescript';
 import { Parser } from 'acorn';
 import { read } from '../../../utils/filesystem.js';
 
-const valid_page_options_array = /** @type {const} */ ([
+export const valid_page_options_array = /** @type {const} */ ([
 	'ssr',
 	'prerender',
 	'csr',
@@ -16,9 +17,6 @@ const valid_page_options_array = /** @type {const} */ ([
 /** @type {Set<string>} */
 const valid_page_options = new Set(valid_page_options_array);
 
-/** @typedef {typeof valid_page_options_array[number]} ValidPageOption */
-/** @typedef {Partial<Record<ValidPageOption, any>>} PageOptions */
-
 const skip_parsing_regex = new RegExp(
 	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
 );

package/src/exports/vite/static_analysis/types.d.ts

@@ -0,0 +1,14 @@
+import type { PrerenderOption, TrailingSlash } from 'types';
+import type { valid_page_options_array } from './index.js';
+
+type ValidPageOption = (typeof valid_page_options_array)[number];
+
+export type PageOptions = Partial<{
+	[K in ValidPageOption]: K extends 'ssr' | 'csr'
+		? boolean
+		: K extends 'prerender'
+			? PrerenderOption
+			: K extends 'trailingSlash'
+				? TrailingSlash
+				: any;
+}>;

package/src/exports/vite/utils.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { posixify } from '../../utils/os.js';
 import { negotiate } from '../../utils/http.js';
 import { escape_html } from '../../utils/escape.js';
+import { stackless } from '../../utils/error.js';
 import { dedent } from '../../core/sync/utils.js';
 import {
 	app_server,
@@ -9,22 +10,19 @@ import {
 	service_worker,
 	sveltekit_env_private
 } from './module_ids.js';
+import { styleText } from 'node:util';
 
 /**
- * Transforms kit.alias to a valid vite.resolve.alias array.
+ * Transforms alias to a valid vite.resolve.alias array.
  *
  * Related to tsconfig path alias creation.
  *
  * @param {import('types').ValidatedKitConfig} config
  * @param {string} root
- * */
+ */
 export function get_config_aliases(config, root) {
 	/** @type {import('vite').Alias[]} */
-	const alias = [
-		// For now, we handle `$lib` specially here rather than make it a default value for
-		// `config.kit.alias` since it has special meaning for packaging, etc.
-		{ find: '$lib', replacement: config.files.lib }
-	];
+	const alias = [];
 
 	for (let [key, value] of Object.entries(config.alias)) {
 		value = posixify(value);
@@ -35,16 +33,16 @@ export function get_config_aliases(config, root) {
 			// Doing just `{ find: key.slice(0, -2) ,..}` would mean `import .. from "key"` would also be matched, which we don't want
 			alias.push({
 				find: new RegExp(`^${escape_for_regexp(key.slice(0, -2))}\\/(.+)$`),
-				replacement: `${path.resolve(root, value)}/$1`
+				replacement: `${posixify(path.resolve(root, value))}/$1`
 			});
 		} else if (key + '/*' in config.alias) {
 			// key and key/* both exist -> the replacement for key needs to happen _only_ on import .. from "key"
 			alias.push({
 				find: new RegExp(`^${escape_for_regexp(key)}$`),
-				replacement: path.resolve(root, value)
+				replacement: posixify(path.resolve(root, value))
 			});
 		} else {
-			alias.push({ find: key, replacement: path.resolve(root, value) });
+			alias.push({ find: key, replacement: posixify(path.resolve(root, value)) });
 		}
 	}
 
@@ -117,16 +115,20 @@ export function not_found(req, res, base) {
 const query_pattern = /\?.*$/s;
 
 /**
- * Removes cwd/lib path from the start of the id
+ * Removes cwd path from the start of the id and replaces any `#`-prefixed
+ * import alias target paths with their alias names.
  * @param {string} id
- * @param {string} lib
+ * @param {Array<{ alias: string, path: string }>} aliases — sorted by path length descending
  * @param {string} cwd
  */
-export function normalize_id(id, lib, cwd) {
+export function normalize_id(id, aliases, cwd) {
 	id = id.replace(query_pattern, '');
 
-	if (id.startsWith(lib)) {
-		id = id.replace(lib, '$lib');
+	for (const { alias, path } of aliases) {
+		if (id === path || id.startsWith(path + '/')) {
+			id = id.replace(path, alias);
+			break;
+		}
 	}
 
 	if (id.startsWith(cwd)) {
@@ -148,34 +150,22 @@ export function normalize_id(id, lib, cwd) {
 	return posixify(id);
 }
 
-/**
- * For times when you need to throw an error, but without
- * displaying a useless stack trace (since the developer
- * can't do anything useful with it)
- * @param {string} message
- */
-export function stackless(message) {
-	const error = new Error(message);
-	error.stack = '';
-	return error;
-}
+export const remote_module_pattern = /[/.]remote(\.[^/]+)+$/;
+export const server_only_module_pattern = /[/.]server(\.[^/]+)+$/;
+export const server_only_directory_pattern = /\/server\//;
 
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');
 
 /**
- * For `error_for_missing_config('instrumentation.server.js', 'kit.experimental.instrumentation.server', true)`,
+ * For `error_for_missing_config('remote functions', 'experimental.remoteFunctions', 'true')`,
  * returns:
  *
  * ```
- * To enable `instrumentation.server.js`, add the following to your `svelte.config.js`:
+ * To enable remote functions, add the following to the SvelteKit plugin in your `vite.config.js`:
  *
  *\`\`\`js
- *	kit:
- *		experimental:
- *			instrumentation:
- *				server: true
- *			}
- *		}
+ *	experimental: {
+ *		remoteFunctions: true
  *	}
  *\`\`\`
  *```
@@ -196,9 +186,24 @@ export function error_for_missing_config(feature_name, path, value) {
 
 	throw stackless(
 		dedent`\
-			To enable ${feature_name}, add the following to your \`svelte.config.js\`:
+			To enable ${feature_name}, add the following to your SvelteKit plugin in \`vite.config.js\`:
 
 			${result}
 		`
 	);
 }
+
+/**
+ * @param {number} status
+ * @param {Request} request
+ */
+export function log_response(status, request) {
+	const url = new URL(request.url);
+	const log = `[${status}] ${request.method} ${url.href.replace(url.origin, '')}`;
+
+	if (status < 400) {
+		console.log(log);
+	} else {
+		console.error(styleText(['bold', 'red'], log));
+	}
+}

package/src/runtime/app/env/internal.js

@@ -1,4 +1,7 @@
-export const version = __SVELTEKIT_APP_VERSION__;
+import { BROWSER } from 'esm-env';
+import { payload } from '../../client/payload.js';
+
+export const version = BROWSER ? payload.version : __SVELTEKIT_APP_VERSION__;
 export let building = false;
 export let prerendering = false;
 
@@ -9,6 +12,3 @@ export function set_building() {
 export function set_prerendering() {
 	prerendering = true;
 }
-
-// force /@vite/client to be injected
-import.meta.hot;

package/src/runtime/app/env/types.d.ts

@@ -14,6 +14,6 @@ export const dev: boolean;
 export const building: boolean;
 
 /**
- * The value of `config.kit.version.name`.
+ * The value of `config.version.name`.
  */
 export const version: string;

package/src/runtime/app/environment/index.js

@@ -1,6 +1,6 @@
-import { dev } from '../env/index.js';
+import { DEV } from 'esm-env';
 export * from '../env/index.js';
 
-if (dev) {
-	console.warn('`$app/environment` is now `$app/env`');
+if (DEV) {
+	console.warn('`$app/environment` is deprecated, use `$app/env` instead');
 }

package/src/runtime/app/forms.js

@@ -1,8 +1,8 @@
 import * as devalue from 'devalue';
 import { BROWSER, DEV } from 'esm-env';
 import { noop } from '../../utils/functions.js';
-import { invalidateAll } from './navigation.js';
-import { app as client_app, applyAction } from '../client/client.js';
+import { refreshAll } from './navigation.js';
+import { app as client_app, applyAction, handle_error } from '../client/client.js';
 import { app as server_app } from '../server/app.js';
 
 export { applyAction };
@@ -30,11 +30,15 @@ export { applyAction };
  * @returns {import('@sveltejs/kit').ActionResult<Success, Failure>}
  */
 export function deserialize(result) {
+	if (result === '') {
+		return { type: 'success', status: 204, data: undefined };
+	}
+
 	const parsed = JSON.parse(result);
 
 	if (parsed.data) {
 		// the decoders should never be initialised at the top-level because `app`
-		// will not be initialised yet if `kit.output.bundleStrategy` is 'single' or 'inline'
+		// will not be initialised yet if `output.bundleStrategy` is 'single' or 'inline'
 		parsed.data = devalue.parse(parsed.data, BROWSER ? client_app.decoders : server_app.decoders);
 	}
 
@@ -102,7 +106,7 @@ export function enhance(form_element, submit = noop) {
 				HTMLFormElement.prototype.reset.call(form_element);
 			}
 			if (shouldInvalidateAll) {
-				await invalidateAll();
+				await refreshAll();
 			}
 		}
 
@@ -197,11 +201,24 @@ export function enhance(form_element, submit = noop) {
 				signal: controller.signal
 			});
 
-			result = deserialize(await response.text());
-			if (result.type === 'error') result.status = response.status;
+			if (response.status === 204) {
+				result = { type: 'success', status: 204 };
+			} else {
+				result = deserialize(await response.text());
+				if (result.type === 'error' || result.type === 'failure') {
+					result.status = response.status;
+				}
+			}
 		} catch (error) {
 			if (/** @type {any} */ (error)?.name === 'AbortError') return;
-			result = { type: 'error', error };
+			result = {
+				type: 'error',
+				error: await handle_error(error, {
+					params: {},
+					route: { id: null },
+					url: new URL(location.href)
+				})
+			};
 		}
 
 		await callback({

package/src/runtime/app/paths/client.js

@@ -1,11 +1,11 @@
-/** @import { Asset, RouteId, RouteIdWithSearchOrHash, Pathname, PathnameWithSearchOrHash, ResolvedPathname } from '$app/types' */
+/** @import { Asset, RouteId, RouteIdWithSearchOrHash, Pathname, PathnameWithSearchOrHash, ResolvedPathname, RouteParams } from '$app/types' */
 /** @import { ResolveArgs } from './types.js' */
 import { base, assets, hash_routing } from './internal/client.js';
 import { resolve_route } from '../../../utils/routing.js';
 import { get_navigation_intent } from '../../client/client.js';
 
 /**
- * Resolve the URL of an asset in your `static` directory, by prefixing it with [`config.kit.paths.assets`](https://svelte.dev/docs/kit/configuration#paths) if configured, or otherwise by prefixing it with the base path.
+ * Resolve the URL of an asset in your `static` directory, by prefixing it with [`config.paths.assets`](https://svelte.dev/docs/kit/configuration#paths) if configured, or otherwise by prefixing it with the base path.
  *
  * During server rendering, the base path is relative and depends on the page currently being rendered.
  *
@@ -59,11 +59,7 @@ export function resolve(...args) {
 		);
 	}
 
-	// The type error is correct here, and if someone doesn't pass params when they should there's a runtime error,
-	// but we don't want to adjust the internal resolve_route function to accept `undefined`, hence the type cast.
-	return (
-		base + pathname_prefix + resolve_route(args[0], /** @type {Record<string, string>} */ (args[1]))
-	);
+	return base + pathname_prefix + resolve_route(args[0], args[1] ?? {});
 }
 
 /**
@@ -84,7 +80,7 @@ export function resolve(...args) {
  * @since 2.52.0
  *
  * @param {Pathname | URL | (string & {})} url
- * @returns {Promise<{ id: RouteId, params: Record<string, string> } | null>}
+ * @returns {Promise<{ [K in RouteId]: { id: K; params: RouteParams<K>; } }[RouteId] | null>}
  */
 export async function match(url) {
 	if (typeof url === 'string') {
@@ -102,5 +98,3 @@ export async function match(url) {
 
 	return null;
 }
-
-export { base, assets, resolve as resolveRoute };

package/src/runtime/app/paths/internal/client.js

@@ -1,4 +1,6 @@
-export const base = __SVELTEKIT_PAYLOAD__?.base ?? __SVELTEKIT_PATHS_BASE__;
-export const assets = __SVELTEKIT_PAYLOAD__?.assets ?? base ?? __SVELTEKIT_PATHS_ASSETS__;
+import { payload } from '../../../client/payload.js';
+
+export const base = payload.base ?? __SVELTEKIT_PATHS_BASE__;
+export const assets = payload.assets ?? base ?? __SVELTEKIT_PATHS_ASSETS__;
 export const app_dir = __SVELTEKIT_APP_DIR__;
 export const hash_routing = __SVELTEKIT_HASH_ROUTING__;

package/src/runtime/app/paths/internal/server.js

@@ -1,30 +1,9 @@
-export let base = __SVELTEKIT_PATHS_BASE__;
+export const base = __SVELTEKIT_PATHS_BASE__;
 export let assets = __SVELTEKIT_PATHS_ASSETS__ || base;
 export const app_dir = __SVELTEKIT_APP_DIR__;
 export const relative = __SVELTEKIT_PATHS_RELATIVE__;
 
-const initial = { base, assets };
-
-/**
- * `base` could be overridden during rendering to be relative;
- * this one's the original non-relative base path
- */
-export const initial_base = initial.base;
-
-/**
- * @param {{ base: string, assets: string }} paths
- */
-export function override(paths) {
-	base = paths.base;
-	assets = paths.assets;
-}
-
-export function reset() {
-	base = initial.base;
-	assets = initial.assets;
-}
-
 /** @param {string} path */
 export function set_assets(path) {
-	assets = initial.assets = path;
+	assets = path;
 }

package/src/runtime/app/paths/public.d.ts

@@ -1,29 +1 @@
-import { RouteIdWithSearchOrHash, PathnameWithSearchOrHash, ResolvedPathname } from '$app/types';
-import { ResolveArgs } from './types.js';
-
 export { resolve, asset, match } from './client.js';
-
-/**
- * A string that matches [`config.kit.paths.base`](https://svelte.dev/docs/kit/configuration#paths).
- *
- * Example usage: `<a href="{base}/your-page">Link</a>`
- *
- * @deprecated Use [`resolve(...)`](https://svelte.dev/docs/kit/$app-paths#resolve) instead
- */
-export let base: '' | `/${string}`;
-
-/**
- * An absolute path that matches [`config.kit.paths.assets`](https://svelte.dev/docs/kit/configuration#paths).
- *
- * > [!NOTE] If a value for `config.kit.paths.assets` is specified, it will be replaced with `'/_svelte_kit_assets'` during `vite dev` or `vite preview`, since the assets don't yet live at their eventual URL.
- *
- * @deprecated Use [`asset(...)`](https://svelte.dev/docs/kit/$app-paths#asset) instead
- */
-export let assets: '' | `https://${string}` | `http://${string}` | '/_svelte_kit_assets';
-
-/**
- * @deprecated Use [`resolve(...)`](https://svelte.dev/docs/kit/$app-paths#resolve) instead
- */
-export function resolveRoute<T extends RouteIdWithSearchOrHash | PathnameWithSearchOrHash>(
-	...args: ResolveArgs<T>
-): ResolvedPathname;

package/src/runtime/app/paths/server.js

@@ -1,8 +1,9 @@
-import { base, assets, relative, initial_base } from './internal/server.js';
+import { base, assets, relative } from './internal/server.js';
 import { resolve_route, find_route } from '../../../utils/routing.js';
 import { decode_pathname } from '../../../utils/url.js';
+import { add_data_suffix } from '../../pathname.js';
 import { try_get_request_store } from '@sveltejs/kit/internal/server';
-import { manifest } from '__sveltekit/server';
+import { manifest } from '../../server/internal.js';
 import { get_hooks } from '__SERVER__/internal.js';
 
 /** @type {import('./client.js').asset} */
@@ -20,13 +21,18 @@ export function resolve(id, params) {
 		);
 	}
 
-	const resolved = resolve_route(id, /** @type {Record<string, string>} */ (params));
+	const resolved = resolve_route(id, params ?? {});
 
 	if (relative) {
 		const store = try_get_request_store();
 
 		if (store && !store.state.prerendering?.fallback) {
-			const after_base = store.event.url.pathname.slice(initial_base.length);
+			// the relative path depth must reflect the URL the browser is actually at, which
+			// for a data request includes the `__data.json` suffix that was stripped during routing
+			const pathname = store.event.isDataRequest
+				? add_data_suffix(store.event.url.pathname)
+				: store.event.url.pathname;
+			const after_base = pathname.slice(base.length);
 			const segments = after_base.split('/').slice(2);
 			const prefix = segments.map(() => '..').join('/') || '.';
 
@@ -74,5 +80,3 @@ export async function match(url) {
 
 	return null;
 }
-
-export { base, assets, resolve as resolveRoute };

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

@@ -1,4 +1,4 @@
-import { read_implementation, manifest } from '__sveltekit/server';
+import { read_implementation, manifest } from '../../server/internal.js';
 import { assets } from '$app/paths/internal/server';
 import { base64_decode } from '../../utils.js';
 

package/src/runtime/app/server/remote/command.js

@@ -77,9 +77,6 @@ export function command(validate_or_fn, maybe_fn) {
 			);
 		}
 
-		state.remote.refreshes ??= new Map();
-		state.remote.reconnects ??= new Map();
-
 		const promise = Promise.resolve(
 			run_remote_function(event, state, true, () => validate(arg), fn)
 		);