@sveltejs/kit 3.0.0-next.6 → 3.0.0-next.8

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

@@ -1,21 +1,20 @@
+/** @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 */
-
 /**
- * @param {import('vite').PreviewServer} vite
- * @param {import('vite').ResolvedConfig} vite_config
- * @param {import('types').ValidatedConfig} svelte_config
+ * @param {PreviewServer} vite
+ * @param {ResolvedConfig} vite_config
+ * @param {ValidatedConfig} svelte_config
  */
 export async function preview(vite, vite_config, svelte_config) {
 	const { paths } = svelte_config.kit;
@@ -37,10 +36,10 @@ export async function preview(vite, vite_config, svelte_config) {
 		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);
@@ -204,12 +203,12 @@ export async function preview(vite, vite_config, svelte_config) {
 		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: () => {
@@ -233,7 +232,7 @@ export async function preview(vite, vite_config, svelte_config) {
 
 /**
  * @param {string} dir
- * @returns {Handler}
+ * @returns {NextHandleFunction}
  */
 const mutable = (dir) =>
 	fs.existsSync(dir)
@@ -245,8 +244,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/utils.js

@@ -18,13 +18,13 @@ import {
  *
  * @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.alias` since it has special meaning for packaging, etc.
-		{ find: '$lib', replacement: config.files.lib }
+		{ find: '$lib', replacement: posixify(config.files.lib) }
 	];
 
 	for (let [key, value] of Object.entries(config.alias)) {
@@ -36,16 +36,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)) });
 		}
 	}
 
@@ -152,17 +152,15 @@ export function normalize_id(id, lib, cwd) {
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');
 
 /**
- * For `error_for_missing_config('instrumentation.server.js', 'experimental.instrumentation.server', true)`,
+ * For `error_for_missing_config('remote functions', 'experimental.remoteFunctions', 'true')`,
  * returns:
  *
  * ```
- * To enable `instrumentation.server.js`, add the following to the SvelteKit plugin in your `vite.config.js`:
+ * To enable remote functions, add the following to the SvelteKit plugin in your `vite.config.js`:
  *
  *\`\`\`js
  *	experimental: {
- *		instrumentation: {
- *			server: true
- *		}
+ *		remoteFunctions: true
  *	}
  *\`\`\`
  *```

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/forms.js

@@ -1,7 +1,7 @@
 import * as devalue from 'devalue';
 import { BROWSER, DEV } from 'esm-env';
 import { noop } from '../../utils/functions.js';
-import { invalidateAll } from './navigation.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';
 
@@ -106,7 +106,7 @@ export function enhance(form_element, submit = noop) {
 				HTMLFormElement.prototype.reset.call(form_element);
 			}
 			if (shouldInvalidateAll) {
-				await invalidateAll();
+				await refreshAll();
 			}
 		}
 

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

@@ -1,4 +1,4 @@
-/** @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';
@@ -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') {

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/server.js

@@ -1,4 +1,4 @@
-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';
@@ -21,7 +21,7 @@ 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();
@@ -32,7 +32,7 @@ export function resolve(id, params) {
 			const pathname = store.event.isDataRequest
 				? add_data_suffix(store.event.url.pathname)
 				: store.event.url.pathname;
-			const after_base = pathname.slice(initial_base.length);
+			const after_base = pathname.slice(base.length);
 			const segments = after_base.split('/').slice(2);
 			const prefix = segments.map(() => '..').join('/') || '.';
 

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

@@ -411,20 +411,14 @@ export function refresh(event, state, internals, payload, fn) {
 
 	const key = create_remote_key(internals.id, payload);
 
-	// `fn()` is invoked eagerly here, which starts running the query immediately.
-	// The resulting promise is normally awaited (and its rejection handled) in
-	// `collect_remote_data`, but some code paths (e.g. a command throwing a
-	// non-redirect error) never reach that point. Attach a no-op `catch` to the
-	// promise so a rejection is always considered handled and can never become an
-	// unhandled promise rejection (which crashes the process on modern Node).
-	// We still store the original promise so `collect_remote_data` can serialize
-	// either its value or its error as before.
-	const promise = fn();
-	promise.catch(() => {});
-
+	// `fn` is stored rather than invoked eagerly. The query is run at the end of
+	// the command/form (in `collect_remote_data`), so that it observes any state
+	// mutations that happen after `refresh()` is called. If the developer re-awaits
+	// the query before the command finishes, the cache entry created by that await
+	// is reused instead of re-running the query.
 	(state.remote.explicit ??= new Map()).set(key, {
 		internals,
-		promise
+		fn
 	});
 }
 

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

@@ -3,7 +3,6 @@ import {
 	navigating as _navigating,
 	updated as _updated
 } from '../../client/state.svelte.js';
-import { stores } from '../../client/client.js';
 
 export const page = {
 	get data() {
@@ -57,5 +56,5 @@ export const updated = {
 	get current() {
 		return _updated.current;
 	},
-	check: stores.updated.check
+	check: _updated.check
 };

package/src/runtime/app/stores.js

@@ -1,101 +1,38 @@
-import { getContext } from 'svelte';
-import { BROWSER, DEV } from 'esm-env';
-import { stores as browser_stores } from '../client/client.js';
+// TODO: remove this file when enough people have migrated to Kit 3
+
+/** @returns {never} */
+function removed() {
+	throw new Error(
+		'`$app/stores` has been removed in favour of `$app/state`. See https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated'
+	);
+}
 
 /**
- * A function that returns all of the contextual stores. On the server, this must be called during component initialization.
- * Only use this if you need to defer store subscription until after the component has mounted, for some reason.
- *
  * @deprecated Use `$app/state` instead (requires Svelte 5, [see docs for more info](https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated))
  */
-export const getStores = () => {
-	const stores = BROWSER ? browser_stores : getContext('__svelte__');
-
-	return {
-		/** @type {typeof page} */
-		page: {
-			subscribe: stores.page.subscribe
-		},
-		/** @type {typeof navigating} */
-		navigating: {
-			subscribe: stores.navigating.subscribe
-		},
-		/** @type {typeof updated} */
-		updated: stores.updated
-	};
-};
+export const getStores = removed;
 
 /**
- * A readable store whose value contains page data.
- *
- * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
- *
  * @deprecated Use `page` from `$app/state` instead (requires Svelte 5, [see docs for more info](https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated))
  * @type {import('svelte/store').Readable<import('@sveltejs/kit').Page>}
  */
 export const page = {
-	subscribe(fn) {
-		const store = DEV ? get_store('page') : getStores().page;
-		return store.subscribe(fn);
-	}
+	subscribe: removed
 };
 
 /**
- * A readable store.
- * When navigating starts, its value is a `Navigation` object with `from`, `to`, `type` and (if `type === 'popstate'`) `delta` properties.
- * When navigating finishes, its value reverts to `null`.
- *
- * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
- *
  * @deprecated Use `navigating` from `$app/state` instead (requires Svelte 5, [see docs for more info](https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated))
  * @type {import('svelte/store').Readable<import('@sveltejs/kit').Navigation | null>}
  */
 export const navigating = {
-	subscribe(fn) {
-		const store = DEV ? get_store('navigating') : getStores().navigating;
-		return store.subscribe(fn);
-	}
+	subscribe: removed
 };
 
 /**
- * A readable store whose initial value is `false`. If [`version.pollInterval`](https://svelte.dev/docs/kit/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
- *
- * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
- *
  * @deprecated Use `updated` from `$app/state` instead (requires Svelte 5, [see docs for more info](https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated))
  * @type {import('svelte/store').Readable<boolean> & { check(): Promise<boolean> }}
  */
 export const updated = {
-	subscribe(fn) {
-		const store = DEV ? get_store('updated') : getStores().updated;
-
-		if (BROWSER) {
-			updated.check = store.check;
-		}
-
-		return store.subscribe(fn);
-	},
-	check: () => {
-		throw new Error(
-			BROWSER
-				? 'Cannot check updated store before subscribing'
-				: 'Can only check updated store in browser'
-		);
-	}
+	subscribe: removed,
+	check: removed
 };
-
-/**
- * @template {keyof ReturnType<typeof getStores>} Name
- * @param {Name} name
- * @returns {ReturnType<typeof getStores>[Name]}
- */
-function get_store(name) {
-	try {
-		return getStores()[name];
-	} catch {
-		throw new Error(
-			`Cannot subscribe to '${name}' store on the server outside of a Svelte component, as it is bound to the current request via component context. This prevents state from leaking between users.` +
-				'For more information, see https://svelte.dev/docs/kit/state-management#avoid-shared-state-on-the-server'
-		);
-	}
-}

package/src/runtime/client/bundle.js

@@ -1,6 +1,6 @@
 /* if `bundleStrategy` is 'single' or 'inline', this file is used as the entry point */
 
-import * as kit from './entry.js';
+import * as kit from './client-entry.js';
 
 // @ts-expect-error
 import * as app from '__sveltekit/manifest';

package/src/runtime/client/client-entry.js

@@ -0,0 +1,3 @@
+// we expose this as a separate entry point (rather than treating client.js as the entry point)
+// so that everything other than `start`/`load_css` can be treeshaken
+export { start, load_css } from './client.js';