@sveltejs/kit 3.0.0-next.2 → 3.0.0-next.21

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

@@ -1,11 +1,8 @@
-/** @import { RequestEvent } from '@sveltejs/kit' */
-/** @import { ServerHooks, MaybePromise, RequestState, RemoteInternals, RequestStore, RemoteLiveQueryUserFunctionReturnType } from 'types' */
-import { parse } from 'devalue';
+/** @import { RequestEvent } from '$app/server' */
+/** @import { MaybePromise, RequestState, RemoteInternals, RequestStore, RemoteLiveQueryUserFunctionReturnType } from 'types' */
 import { error } from '@sveltejs/kit';
-import { hydratable } from 'svelte';
-import { with_request_store, get_request_store } from '@sveltejs/kit/internal/server';
-import { create_remote_key, stringify } from '../../../shared.js';
-import { noop } from '../../../../utils/functions.js';
+import { ValidationError } from '@sveltejs/kit/internal';
+import { with_request_store } from '@sveltejs/kit/internal/server';
 
 /**
  * @param {any} validate_or_fn
@@ -30,21 +27,12 @@ export function create_validator(validate_or_fn, maybe_fn) {
 	// use https://standardschema.dev validator if provided
 	if ('~standard' in validate_or_fn) {
 		return async (arg) => {
-			// Get event before async validation to ensure it's available in server environments without AsyncLocalStorage, too
-			const { event, state } = get_request_store();
-
 			// access property and call method in one go to preserve potential this context
 			const result = await validate_or_fn['~standard'].validate(arg);
 
 			// if the `issues` field exists, the validation failed
 			if (result.issues) {
-				error(
-					400,
-					await state.handleValidationError({
-						issues: result.issues,
-						event
-					})
-				);
+				throw new ValidationError(result.issues);
 			}
 
 			return result.value;
@@ -76,38 +64,13 @@ export async function get_response(internals, payload, state, get_result) {
 	await 0;
 
 	const cache = get_cache(internals, state);
-	const entry = (cache[payload] ??= {
-		serialize: false,
-		data: get_result()
-	});
-
-	entry.serialize ||= !!state.is_in_universal_load;
-
-	if (state.is_in_render && internals.id) {
-		const remote_key = create_remote_key(internals.id, payload);
-
-		void Promise.resolve(entry.data)
-			.then((value) => {
-				void hydratable(remote_key, () => stringify(value, state.transport));
-			})
-			.catch(noop);
-	}
 
-	return entry.data;
-}
-
-/**
- * @param {any} data
- * @param {ServerHooks['transport']} transport
- */
-export function parse_remote_response(data, transport) {
-	/** @type {Record<string, any>} */
-	const revivers = {};
-	for (const key in transport) {
-		revivers[key] = transport[key].decode;
+	if (!state.is_in_remote_query) {
+		// if this is a top-level (not nested) `await myQuery()`, include it in the serialized response
+		get_implicit_lookup(internals, state)[payload] = get_result;
 	}
 
-	return parse(data, revivers);
+	return (cache[payload] ??= get_result());
 }
 
 /**
@@ -117,38 +80,55 @@ export function parse_remote_response(data, transport) {
  * @returns {RequestStore}
  */
 function derive_remote_function_event(event, state, allow_cookies) {
-	return {
-		event: {
-			...event,
-			setHeaders: () => {
-				throw new Error('setHeaders is not allowed in remote functions');
+	/** @type {RequestEvent} */
+	const derived = {
+		...event,
+		setHeaders: () => {
+			throw new Error('setHeaders is not allowed in remote functions');
+		},
+		cookies: {
+			...event.cookies,
+			set: (name, value, opts) => {
+				if (!allow_cookies) {
+					throw new Error('Cannot set cookies in `query` or `prerender` functions');
+				}
+
+				if (opts.path && !opts.path.startsWith('/')) {
+					throw new Error('Cookies set in remote functions must have an absolute path');
+				}
+
+				return event.cookies.set(name, value, opts);
 			},
-			cookies: {
-				...event.cookies,
-				set: (name, value, opts) => {
-					if (!allow_cookies) {
-						throw new Error('Cannot set cookies in `query` or `prerender` functions');
-					}
-
-					if (opts.path && !opts.path.startsWith('/')) {
-						throw new Error('Cookies set in remote functions must have an absolute path');
-					}
-
-					return event.cookies.set(name, value, opts);
-				},
-				delete: (name, opts) => {
-					if (!allow_cookies) {
-						throw new Error('Cannot delete cookies in `query` or `prerender` functions');
-					}
-
-					if (opts.path && !opts.path.startsWith('/')) {
-						throw new Error('Cookies deleted in remote functions must have an absolute path');
-					}
-
-					return event.cookies.delete(name, opts);
+			delete: (name, opts) => {
+				if (!allow_cookies) {
+					throw new Error('Cannot delete cookies in `query` or `prerender` functions');
 				}
+
+				if (opts.path && !opts.path.startsWith('/')) {
+					throw new Error('Cookies deleted in remote functions must have an absolute path');
+				}
+
+				return event.cookies.delete(name, opts);
 			}
-		},
+		}
+	};
+
+	if (state.is_in_remote_query) {
+		for (const property of ['url', 'params', 'route']) {
+			// non-enumerable so spreading for a nested derivation doesn't invoke the getter
+			Object.defineProperty(derived, property, {
+				enumerable: false,
+				get() {
+					throw new Error(
+						`Cannot access event.${property} in a query. Pass the value as an argument to the query instead`
+					);
+				}
+			});
+		}
+	}
+
+	return {
+		event: derived,
 		state: {
 			...state,
 			is_in_remote_function: true
@@ -239,10 +219,15 @@ function to_iterator(source, name) {
 }
 
 /**
+ * Note that `state` is deliberately not optional: resources that capture the request
+ * state at creation must pass it explicitly, because reading it from the request store
+ * at call time is only equivalent on runtimes with `AsyncLocalStorage` support.
+ * Callers without a captured state (such as the module-level `form` instance getters)
+ * should pass `get_request_store().state` themselves.
  * @param {RemoteInternals} internals
  * @param {RequestState} state
  */
-export function get_cache(internals, state = get_request_store().state) {
+export function get_cache(internals, state) {
 	let cache = state.remote.data?.get(internals);
 
 	if (cache === undefined) {
@@ -252,3 +237,18 @@ export function get_cache(internals, state = get_request_store().state) {
 
 	return cache;
 }
+
+/**
+ * @param {RemoteInternals} internals
+ * @param {RequestState} state
+ */
+export function get_implicit_lookup(internals, state) {
+	let cache = state.remote.implicit?.get(internals);
+
+	if (cache === undefined) {
+		cache = {};
+		(state.remote.implicit ??= new Map()).set(internals, cache);
+	}
+
+	return cache;
+}

package/src/runtime/app/service-worker/index.js

@@ -0,0 +1,24 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="esnext" />
+/// <reference lib="webworker" />
+
+import { DEV } from 'esm-env';
+
+/**
+ * The execution context of a service worker. This export exists to make it easier to
+ * use service workers with the correct types, provided the importing module is governed
+ * by a `tsconfig.json` that extends [`$app/tsconfig/service-worker`](https://svelte.dev/docs/kit/$app-tsconfig-service-worker).
+ *
+ */
+export const self = /** @type {ServiceWorkerGlobalScope} */ (
+	/** @type {unknown} */ (globalThis.self)
+);
+
+if (DEV) {
+	if (
+		typeof ServiceWorkerGlobalScope === 'undefined' ||
+		!(self instanceof ServiceWorkerGlobalScope)
+	) {
+		throw new Error('The `$app/service-worker` module can only be imported into a service worker');
+	}
+}

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() {
@@ -21,6 +20,9 @@ export const page = {
 	get route() {
 		return _page.route;
 	},
+	get shallow() {
+		return _page.shallow;
+	},
 	get state() {
 		return _page.state;
 	},
@@ -57,5 +59,5 @@ export const updated = {
 	get current() {
 		return _updated.current;
 	},
-	check: stores.updated.check
+	check: _updated.check
 };

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

@@ -1,3 +1,5 @@
+/** @import { Navigation } from '$app/navigation' */
+/** @import { Page } from '$app/state' */
 import {
 	page as client_page,
 	navigating as client_navigating,
@@ -14,8 +16,8 @@ import { BROWSER } from 'esm-env';
  * A read-only reactive object with information about the current page, serving several use cases:
  * - retrieving the combined `data` of all pages/layouts anywhere in your component tree (also see [loading data](https://svelte.dev/docs/kit/load))
  * - retrieving the current value of the `form` prop anywhere in your component tree (also see [form actions](https://svelte.dev/docs/kit/form-actions))
- * - retrieving the page state that was set through `goto`, `pushState` or `replaceState` (also see [goto](https://svelte.dev/docs/kit/$app-navigation#goto) and [shallow routing](https://svelte.dev/docs/kit/shallow-routing))
- * - retrieving metadata such as the URL you're on, the current route and its parameters, and whether or not there was an error
+ * - retrieving the page state that was set through `goto` (also see [goto](https://svelte.dev/docs/kit/$app-navigation#goto) and [shallow routing](https://svelte.dev/docs/kit/shallow-routing))
+ * - retrieving metadata such as the URL you're on, the current route and its parameters, the target of a shallow navigation, and whether or not there was an error
  *
  * ```svelte
  * <!--- file: +layout.svelte --->
@@ -45,20 +47,20 @@ import { BROWSER } from 'esm-env';
  *
  * On the server, values can only be read during rendering (in other words _not_ in e.g. `load` functions). In the browser, the values can be read at any time.
  *
- * @type {import('@sveltejs/kit').Page}
+ * @type {Page}
  */
 export const page = BROWSER ? client_page : server_page;
 
 /**
  * A read-only object representing an in-progress navigation, with `from`, `to`, `type` and (if `type === 'popstate'`) `delta` properties.
  * Values are `null` when no navigation is occurring, or during server rendering.
- * @type {import('@sveltejs/kit').Navigation | { from: null, to: null, type: null, willUnload: null, delta: null, complete: null }}
+ * @type {Navigation | { from: null, to: null, type: null, willUnload: null, delta: null, complete: null }}
  */
 // @ts-expect-error
 export const navigating = BROWSER ? client_navigating : server_navigating;
 
 /**
- * A read-only reactive value that's initially `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 `current` to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
+ * A read-only reactive value that's initially `false`. SvelteKit checks for new versions on data, remote, and form action responses (via the `x-sveltekit-version` header), when the tab regains focus or becomes visible, and on a poll interval (see [`version.pollInterval`](https://svelte.dev/docs/kit/configuration#version)). `updated.current` is set to `true` when a new version is detected. `updated.check()` will force an immediate check, regardless of polling.
  * @type {{ get current(): boolean; check(): Promise<boolean>; }}
  */
 export const updated = BROWSER ? client_updated : server_updated;

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

@@ -0,0 +1,72 @@
+import type {
+	LayoutParams as AppLayoutParams,
+	ResolvedPathname,
+	RouteId as AppRouteId
+} from '$app/types';
+
+export * from './index.js';
+
+export type ReadonlyURLSearchParams = Omit<URLSearchParams, 'set' | 'append' | 'delete' | 'sort'>;
+
+export type ReadonlyURL = Readonly<
+	Omit<URL, 'searchParams'> & {
+		searchParams: ReadonlyURLSearchParams;
+	}
+>;
+
+/**
+ * The shape of the [`page`](https://svelte.dev/docs/kit/$app-state#page) reactive object.
+ */
+export interface Page<
+	Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+	RouteId extends AppRouteId | null = AppRouteId | null
+> {
+	/**
+	 * The URL of the current page.
+	 */
+	url: ReadonlyURL & { readonly pathname: ResolvedPathname | (string & {}) };
+	/**
+	 * The parameters of the current page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
+	 */
+	params: Params;
+	/**
+	 * Info about the current route.
+	 */
+	route: {
+		/**
+		 * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+		 */
+		id: RouteId;
+	};
+	/**
+	 * HTTP status code of the current page.
+	 */
+	status: number;
+	/**
+	 * The error object of the current page, if any. Filled from the `handleError` hooks.
+	 */
+	error: App.Error | null;
+	/**
+	 * The merged result of all data from all `load` functions on the current page. You can type a common denominator through `App.PageData`.
+	 */
+	data: App.PageData & Record<string, any>;
+	/**
+	 * The page state, which can be manipulated using [`goto`](https://svelte.dev/docs/kit/$app-navigation#goto) from `$app/navigation`.
+	 */
+	state: App.PageState;
+	/**
+	 * Information about the target of the current shallow navigation, or `null` if no shallow navigation has occurred.
+	 */
+	shallow: {
+		/** Parameters of the target route, or `null` if the URL does not resolve to a route. */
+		params: AppLayoutParams<'/'> | null;
+		/** Info about the target route, or `null` if the URL does not resolve to a route. */
+		route: { id: AppRouteId } | null;
+		/** The normalized URL passed to `goto(..., { shallow: true })`. */
+		url: ReadonlyURL;
+	} | null;
+	/**
+	 * Filled only after a form submission. See [form actions](https://svelte.dev/docs/kit/form-actions) for more info.
+	 */
+	form: any;
+}

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

@@ -33,6 +33,9 @@ export const page = {
 	get route() {
 		return (DEV ? context_dev('page.route') : context()).page.route;
 	},
+	get shallow() {
+		return (DEV ? context_dev('page.shallow') : context()).page.shallow;
+	},
 	get state() {
 		return (DEV ? context_dev('page.state') : context()).page.state;
 	},

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>}
+ * @type {import('svelte/store').Readable<import('$app/state').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>}
+ * @type {import('svelte/store').Readable<import('$app/navigation').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';