@sveltejs/kit 3.0.0-next.0 → 3.0.0-next.10

package/src/types/internal.d.ts

@@ -1,4 +1,4 @@
-import { SvelteComponent } from 'svelte';
+import { Component } from 'svelte';
 import {
 	Config,
 	ServerLoad,
@@ -17,7 +17,6 @@ import {
 	RequestEvent,
 	SSRManifest,
 	Emulator,
-	Adapter,
 	ServerInit,
 	ClientInit,
 	Transport,
@@ -34,7 +33,7 @@ import {
 	TrailingSlash
 } from './private.js';
 import { Span } from '@opentelemetry/api';
-import type { PageOptions } from '../exports/vite/static_analysis/index.js';
+import { PageOptions } from '../exports/vite/static_analysis/types.js';
 import { SharedIterator } from '../utils/shared-iterator.js';
 
 export interface ServerModule {
@@ -44,7 +43,6 @@ export interface ServerModule {
 export interface ServerInternalModule {
 	set_assets(path: string): void;
 	set_building(): void;
-	set_env(environment: Record<string, string>): void;
 	set_manifest(manifest: SSRManifest): void;
 	set_prerendering(): void;
 	set_read_implementation(implementation: (path: string) => ReadableStream): void;
@@ -101,6 +99,9 @@ export interface BuildData {
 		routes?: SSRClientRoute[];
 		stylesheets: string[];
 		fonts: string[];
+		/**
+		 * Whether the client uses public dynamic env vars — `$env/dynamic/public` or `$app/env/public`.
+		 */
 		uses_env_dynamic_public: boolean;
 		/** Only set in case of `bundleStrategy === 'inline'`. */
 		inline?: {
@@ -112,7 +113,7 @@ export interface BuildData {
 }
 
 export interface CSRPageNode {
-	component: typeof SvelteComponent;
+	component: Component;
 	universal: {
 		load?: Load;
 		trailingSlash?: TrailingSlash;
@@ -194,7 +195,7 @@ export class InternalServer extends Server {
 }
 
 export interface ManifestData {
-	/** Static files from `kit.config.files.assets`. */
+	/** Static files from `config.files.assets`. */
 	assets: Asset[];
 	hooks: {
 		client: string | null;
@@ -203,7 +204,7 @@ export interface ManifestData {
 	};
 	nodes: PageNode[];
 	routes: RouteData[];
-	matchers: Record<string, string>;
+	params: string | null;
 }
 
 export interface RemoteChunk {
@@ -236,10 +237,7 @@ export interface PrerenderOptions {
 	cache?: string; // including this here is a bit of a hack, but it makes it easy to add <meta http-equiv>
 	fallback?: boolean;
 	dependencies: Map<string, PrerenderDependency>;
-	/**
-	 * For each key the (possibly still pending) result of a prerendered remote function.
-	 * Used to deduplicate requests to the same remote function with the same arguments.
-	 */
+	/** Results of remote `prerender` functions, shared across the whole prerender run so that each only executes once */
 	remote_responses: Map<string, Promise<any>>;
 	/** True for the duration of a call to the `reroute` hook */
 	inside_reroute?: boolean;
@@ -249,7 +247,7 @@ export type RecursiveRequired<T> = {
 	// Recursive implementation of TypeScript's Required utility type.
 	// Will recursively continue until it reaches a primitive or Function
 	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-	[K in keyof T]-?: Extract<T[K], Function> extends never // If it does not have a Function type
+	[K in keyof T]-?: Extract<T[K], Function | (`${string}:` & {})> extends never // If it does not have a Function type
 		? RecursiveRequired<T[K]> // recursively continue through.
 		: T[K]; // Use the exact type for everything else
 };
@@ -296,6 +294,7 @@ export interface RouteData {
 
 export type ServerRedirectNode = {
 	type: 'redirect';
+	status: number;
 	location: string;
 };
 
@@ -307,38 +306,42 @@ export type ServerNodesResponse = {
 	nodes: Array<ServerDataNode | ServerDataSkippedNode | ServerErrorNode | null>;
 };
 
+export type RemoteFunctionDataNode = {
+	/** value */
+	v?: any;
+	/** error */
+	e?: App.Error;
+};
+
+export type RemoteFunctionData = {
+	/** The result of a command/form invocation */
+	_?: any;
+	/** `prerender` data that was accessed during the request */
+	p?: Record<string, RemoteFunctionDataNode>;
+	/** `query` or `query.batch` data that was accessed during the request */
+	q?: Record<string, RemoteFunctionDataNode>;
+	/** `query.live` data that was accessed during the request */
+	l?: Record<string, RemoteFunctionDataNode>;
+	/** `form` outputs (result/issues/input) from a non-enhanced submission, keyed by the client-side action id */
+	f?: Record<string, RemoteFunctionDataNode>;
+	/** Whether there were any refreshes/reconnects during the request */
+	r?: true;
+	/** The redirect location, if any */
+	redirect?: string;
+};
+
 export type RemoteFunctionResponse =
 	| (ServerRedirectNode & {
-			/** devalue'd Record<string, any> */
-			refreshes?: string;
-			/** devalue'd Record<string, any> */
-			reconnects?: string;
+			/** stringified RemoteFunctionData */
+			data: string;
 	  })
 	| ServerErrorNode
 	| {
 			type: 'result';
-			result: string;
-			/** devalue'd Record<string, any> */
-			refreshes: string | undefined;
-			/** devalue'd Record<string, any> */
-			reconnects: string | undefined;
+			/** stringified RemoteFunctionData */
+			data: string;
 	  };
 
-export type RemoteSingleflightResult = {
-	type: 'result';
-	data: any;
-};
-
-export type RemoteSingleflightError = {
-	type: 'error';
-	status?: number;
-	error: App.Error;
-};
-
-export type RemoteSingleflightEntry = RemoteSingleflightResult | RemoteSingleflightError;
-
-export type RemoteSingleflightMap = Record<string, RemoteSingleflightEntry>;
-
 export type RemoteLiveQueryUserFunctionReturnType<Output> = MaybePromise<
 	| AsyncGenerator<Output>
 	| AsyncIterator<Output>
@@ -388,10 +391,6 @@ export interface ServerDataSkippedNode {
 export interface ServerErrorNode {
 	type: 'error';
 	error: App.Error;
-	/**
-	 * Only set for HttpErrors.
-	 */
-	status?: number;
 }
 
 export interface ServerMetadataRoute {
@@ -418,27 +417,7 @@ export interface ServerMetadata {
 	remotes: Map<string, Map<string, { type: RemoteInternals['type']; dynamic: boolean }>>;
 }
 
-export interface SSRComponent {
-	default: {
-		render(
-			props: Record<string, any>,
-			opts: { context: Map<any, any>; csp?: { nonce?: string; hash?: boolean } }
-		): {
-			html: string;
-			head: string;
-			css: {
-				code: string;
-				map: any; // TODO
-			};
-			/** Until we require all Svelte versions that support hashes, this might not be defined */
-			hashes?: {
-				script: Array<`sha256-${string}`>;
-			};
-		};
-	};
-}
-
-export type SSRComponentLoader = () => Promise<SSRComponent>;
+export type SSRComponentLoader = () => Promise<Component>;
 
 export interface UniversalNode {
 	/** Is `null` in case static analysis succeeds but the node is ssr=false */
@@ -477,7 +456,10 @@ export interface SSRNode {
 
 	/**
 	 * During development, all styles are inlined for the page to avoid FOUC.
-	 * But in production, this stores styles that are below the inline threshold
+	 * But in production, this stores styles that are below the inline threshold.
+	 * It returns a Promise during development because Vite needs to load the
+	 * modules on demand. But in production, the contents have been precomputed
+	 * during the build, so it can return synchronously.
 	 */
 	inline_styles?(): MaybePromise<
 		Record<string, string | ((assets: string, base: string) => string)>
@@ -494,7 +476,6 @@ export type SSRNodeLoader = () => Promise<SSRNode>;
 
 export interface SSROptions {
 	app_template_contains_nonce: boolean;
-	async: boolean;
 	csp: ValidatedConfig['kit']['csp'];
 	csrf_check_origin: boolean;
 	csrf_trusted_origins: string[];
@@ -502,10 +483,9 @@ export interface SSROptions {
 	hash_routing: boolean;
 	hooks: ServerHooks;
 	link_header_preload: ValidatedConfig['kit']['output']['linkHeaderPreload'];
-	root: SSRComponent['default'];
+	paths_origin: string | undefined;
 	service_worker: boolean;
 	service_worker_options: RegistrationOptions;
-	server_error_boundaries: boolean;
 	templates: {
 		app(values: {
 			head: string;
@@ -598,13 +578,12 @@ export interface Uses {
 	search_params: Set<string>;
 }
 
-export type ValidatedConfig = Config & {
+export type ValidatedConfig = Omit<Config, 'kit'> & {
 	kit: ValidatedKitConfig;
 	extensions: string[];
 };
 
-// TODO: remove the omit in 4.0
-export type ValidatedKitConfig = Omit<RecursiveRequired<KitConfig>, 'adapter'>;
+export type ValidatedKitConfig = RecursiveRequired<KitConfig>;
 
 export type BinaryFormMeta = {
 	remote_refreshes?: string[];
@@ -663,6 +642,11 @@ export interface RemoteCommandInternals extends BaseRemoteInternals {
 
 export interface RemoteFormInternals extends BaseRemoteInternals {
 	type: 'form';
+	/**
+	 * For keyed (`form.for(key)`) instances: the id as the client computes it
+	 * (the key is JSON-stringified but not URI-encoded, unlike `id`)
+	 */
+	action_id?: string;
 	fn(body: Record<string, any>, meta: BinaryFormMeta, form_data: FormData | null): Promise<any>;
 }
 
@@ -708,15 +692,26 @@ export interface RequestState {
 		record_span: RecordSpan;
 	};
 	readonly remote: {
-		data: null | Map<
-			RemoteInternals,
-			Record<string, { serialize: boolean; data: MaybePromise<any> }>
+		/** Resolved query/prerender data, populated by `await myQuery()` or `myQuery.set(...)` */
+		data: null | Map<RemoteInternals, Record<string, MaybePromise<any>>>;
+		/**
+		 * Data that is implicitly included because it was awaited during render.
+		 * This is serialized during SSR if the promise already resolved
+		 */
+		implicit: null | Map<RemoteInternals, Record<string, () => MaybePromise<any>>>;
+		/**
+		 * Data that is explicitly included because of a `set(...)` or `refresh()`.
+		 * This is always awaited
+		 */
+		explicit: null | Map<
+			string,
+			{
+				internals: RemoteInternals;
+				fn: () => Promise<any>;
+			}
 		>;
 		/** Instances created via `myForm.for(...)` */
 		forms: null | Map<string, any>;
-		/** A map of remote function key to corresponding single-flight-mutation promise */
-		refreshes: null | Map<string, Promise<any>>;
-		reconnects: null | Map<string, Promise<void>>;
 		/** A map of remote function ID to payloads requested for refreshing by the client */
 		requested: null | Map<string, string[]>;
 		/** A map of query.batch ID to payloads requested for that batch within the same macrotask */
@@ -739,6 +734,8 @@ export interface RequestState {
 		live_iterators: null | Map<string, SharedIterator<any>>;
 	};
 	readonly is_in_remote_function: boolean;
+	readonly is_in_remote_form_or_command: boolean;
+	readonly is_in_remote_query: boolean;
 	readonly is_in_render: boolean;
 	readonly is_in_universal_load: boolean;
 }
@@ -748,5 +745,23 @@ export interface RequestStore {
 	state: RequestState;
 }
 
+/** Type of the `__sveltekit_abc123` object in the init `<script>` */
+export interface SvelteKitPayload {
+	/** The application version */
+	version: string;
+	/** The basepath, usually relative to the current page */
+	base: string;
+	/** Path to externally-hosted assets */
+	assets?: string;
+	/** Public environment variables */
+	env?: Record<string, string>;
+	/** Serialized data from query/form/command functions */
+	data?: RemoteFunctionData;
+	/** Create a placeholder promise */
+	defer?: (id: number) => Promise<any>;
+	/** Resolve a placeholder promise */
+	resolve?: (data: { id: number; data: any; error: any }) => void;
+}
+
 export * from '../exports/index.js';
 export * from './private.js';

package/src/types/private.d.ts

@@ -61,7 +61,10 @@ export namespace Csp {
 		| 'unsafe-eval'
 		| 'unsafe-hashes'
 		| 'unsafe-inline'
+		| 'unsafe-allow-redirects'
+		| 'unsafe-webtransport-hashes'
 		| 'wasm-unsafe-eval'
+		| 'trusted-types-eval'
 		| 'none';
 	type CryptoSource = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
 	type FrameSource = HostSource | SchemeSource | 'self' | 'none';
@@ -70,7 +73,16 @@ export namespace Csp {
 	type HostProtocolSchemes = `${string}://` | '';
 	type HttpDelineator = '/' | '?' | '#' | '\\';
 	type PortScheme = `:${number}` | '' | ':*';
-	type SchemeSource = 'http:' | 'https:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:';
+	type SchemeSource =
+		| 'http:'
+		| 'https:'
+		| 'ws:'
+		| 'wss:'
+		| 'data:'
+		| 'mediastream:'
+		| 'blob:'
+		| 'filesystem:'
+		| (`${string}:` & {});
 	type Source = HostSource | SchemeSource | CryptoSource | BaseSource;
 	type Sources = Source[];
 }
@@ -212,6 +224,10 @@ export interface PrerenderUnseenRoutesHandler {
 	(details: { routes: string[]; message: string }): void;
 }
 
+export interface PrerenderInvalidUrlHandler {
+	(details: { href: string; referrer: string | null; message: string }): void;
+}
+
 export type PrerenderHttpErrorHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderHttpErrorHandler;
 export type PrerenderMissingIdHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderMissingIdHandler;
 export type PrerenderUnseenRoutesHandlerValue =
@@ -224,6 +240,11 @@ export type PrerenderEntryGeneratorMismatchHandlerValue =
 	| 'warn'
 	| 'ignore'
 	| PrerenderEntryGeneratorMismatchHandler;
+export type PrerenderInvalidUrlHandlerValue =
+	| 'fail'
+	| 'warn'
+	| 'ignore'
+	| PrerenderInvalidUrlHandler;
 
 export type PrerenderOption = boolean | 'auto';
 
@@ -252,3 +273,14 @@ export type DeepPartial<T> = T extends Record<PropertyKey, unknown> | unknown[]
 	: T | undefined;
 
 export type IsAny<T> = 0 extends 1 & T ? true : false;
+
+export type HasNonOptionalBoolean<T> =
+	IsAny<T> extends true
+		? never
+		: [T] extends [boolean]
+			? true
+			: T extends Array<infer U>
+				? HasNonOptionalBoolean<U>
+				: T extends Record<string, any>
+					? { [K in keyof T]: HasNonOptionalBoolean<T[K]> }[keyof T]
+					: never;

package/src/utils/error.js

@@ -1,5 +1,17 @@
 import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
 
+/**
+ * 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;
+}
+
 /**
  * @param {unknown} err
  * @return {Error}
@@ -18,16 +30,24 @@ export function coalesce_to_error(err) {
  * @param {unknown} error
  */
 export function normalize_error(error) {
-	return /** @type {import('../exports/internal/index.js').Redirect | HttpError | SvelteKitError | Error} */ (
+	return /** @type {import('../exports/internal/shared.js').Redirect | HttpError | SvelteKitError | Error} */ (
 		error
 	);
 }
 
 /**
- * @param {unknown} error
+ * @param {any} transformed
+ * @param {any} [error]
  */
-export function get_status(error) {
-	return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+export function get_status(transformed, error) {
+	const err = error ?? transformed;
+	const status = err instanceof HttpError || err instanceof SvelteKitError ? err.status : 500;
+
+	if (error == null || typeof transformed?.status !== 'number') {
+		return status;
+	} else {
+		return transformed.status;
+	}
 }
 
 /**

package/src/utils/import.js

@@ -2,7 +2,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 /**
- * Resolves a peer dependency relative to the current working directory. Duplicated with `packages/adapter-auto`
+ * Resolves a peer dependency relative to the current working directory.
+ *
+ * Mainly used to resolve the correct Vite package when an app's SvelteKit is a
+ * linked local repository.
+ *
+ * Duplicated with `packages/adapter-auto`
  * @param {string} dependency
  * @param {string} root
  */

package/src/utils/imports.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Reads the `imports` field from the package.json at the given directory.
+ * @param {string} cwd
+ * @returns {Record<string, string | Record<string, string>> | undefined}
+ */
+export function read_package_imports(cwd) {
+	const pkg_path = path.resolve(cwd, 'package.json');
+	if (fs.existsSync(pkg_path)) {
+		try {
+			return JSON.parse(fs.readFileSync(pkg_path, 'utf-8')).imports;
+		} catch {
+			// malformed package.json — ignore, the user will see other errors
+		}
+	}
+}
+
+/**
+ * Normalizes an import value to a string path, handling both string values
+ * and conditional export objects (using the `default` key).
+ * @param {string | Record<string, string>} value
+ * @returns {string | null}
+ */
+export function normalize_import_value(value) {
+	if (typeof value === 'string') {
+		return value.replace(/^\.\//, '');
+	}
+	if (value && typeof value === 'object' && typeof value.default === 'string') {
+		return value.default.replace(/^\.\//, '');
+	}
+	return null;
+}
+
+/**
+ * Returns the `#`-prefixed import keys from the package.json `imports` field.
+ * @param {string} cwd
+ * @returns {string[]}
+ */
+export function get_hash_import_keys(cwd) {
+	const imports = read_package_imports(cwd);
+	if (!imports) return [];
+	return Object.keys(imports).filter((key) => key.startsWith('#'));
+}
+
+/**
+ * Computes alias entries for `normalize_id` from the package.json `imports` field.
+ * Each entry maps a `#xx` alias to its absolute target path. Entries are sorted
+ * by path length descending so that longer/more-specific paths are matched first.
+ *
+ * @param {string} root
+ * @param {(p: string) => string} [normalize] - optional path normalizer (e.g. `vite.normalizePath`)
+ * @returns {Array<{ alias: string, path: string }>}
+ */
+export function get_import_aliases(root, normalize) {
+	const imports = read_package_imports(root);
+	if (!imports) return [];
+
+	/** @type {Array<{ alias: string, path: string }>} */
+	const aliases = [];
+
+	for (const [key, raw_value] of Object.entries(imports)) {
+		if (!key.startsWith('#')) continue;
+
+		const value = normalize_import_value(raw_value);
+		if (!value) continue;
+
+		// For `#xx/*` imports, the target directory is the value without `/*`
+		// For `#xx` imports, the target is the file itself
+		const target = value.endsWith('/*') ? value.slice(0, -2) : value;
+		if (target.includes('*')) continue; // not sure if this is even allowed in Node, anyway it's too niche/complex to support here
+		const abs = path.resolve(root, target);
+		const alias = key.endsWith('/*') ? key.slice(0, -2) : key;
+
+		aliases.push({ alias, path: normalize ? normalize(abs) : abs });
+	}
+
+	// Sort by path length descending so longer/more-specific paths match first
+	aliases.sort((a, b) => b.path.length - a.path.length);
+
+	return aliases;
+}

package/src/utils/mime.js

@@ -0,0 +1,9 @@
+import { mimes, lookup } from 'mrmime';
+
+// `mrmime` does not include `.ico` in its database. The IANA-registered
+// type is `image/vnd.microsoft.icon`, but `image/x-icon` is the
+// semi-official type that is universally supported by browsers and other
+// tools, so we use that.
+mimes['ico'] = 'image/x-icon';
+
+export { lookup };

package/src/utils/params.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+/**
+ * @param {import('types').RouteData[]} routes
+ * @returns {Set<string>}
+ */
+export function collect_matcher_names(routes) {
+	/** @type {Set<string>} */
+	const names = new Set();
+
+	for (const route of routes) {
+		for (const param of route.params) {
+			if (param.matcher) names.add(param.matcher);
+		}
+	}
+
+	return names;
+}
+
+/**
+ * @param {Record<string, unknown>} params
+ * @param {Set<string>} names
+ * @param {string} [file]
+ */
+export function validate_param_matchers(params, names, file) {
+	for (const name of names) {
+		if (!(name in params)) {
+			throw new Error(`No matcher found for parameter '${name}'${file ? ` in ${file}` : ''}`);
+		}
+	}
+}
+
+/**
+ * @param {{
+ *   routes: import('types').RouteData[];
+ *   params_path: string | null;
+ *   root: string;
+ *   load?: (file: string) => Promise<Record<string, unknown>>;
+ * }} opts
+ * @returns {Promise<Record<string, import('@sveltejs/kit').ParamMatcher> | null>}
+ */
+export async function load_and_validate_params({ routes, params_path, root, load }) {
+	const names = collect_matcher_names(routes);
+
+	if (names.size === 0) return null;
+
+	if (!params_path) {
+		throw new Error(`No matcher found for parameter '${names.values().next().value}'`);
+	}
+
+	const file = path.resolve(root, params_path);
+	const module = load ? await load(file) : await import(pathToFileURL(file).href);
+
+	if (!module.params || typeof module.params !== 'object') {
+		throw new Error(`${params_path} does not export \`params\` from \`defineParams\``);
+	}
+
+	validate_param_matchers(
+		/** @type {Record<string, unknown>} */ (module.params),
+		names,
+		params_path
+	);
+
+	return /** @type {Record<string, import('@sveltejs/kit').ParamMatcher>} */ (module.params);
+}