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

package/src/core/sync/write_types/index.js

@@ -1,10 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import MagicString from 'magic-string';
-import { rimraf, walk } from '../../../utils/filesystem.js';
+import { walk, resolve_entry } from '../../../utils/filesystem.js';
 import { compact } from '../../../utils/array.js';
 import { posixify } from '../../../utils/os.js';
 import { ts } from '../ts.js';
+import { is_page_route } from '../create_manifest_data/index.js';
 const remove_relative_parent_traversals = (/** @type {string} */ path) =>
 	path.replace(/\.\.\//g, '');
 const is_whitespace = (/** @type {string} */ char) => /\s/.test(char);
@@ -48,7 +49,7 @@ export function write_all_types(config, manifest_data, root) {
 		for (const file of walk(types_dir)) {
 			const dir = path.dirname(file);
 			if (!expected_directories.has(dir)) {
-				rimraf(path.join(types_dir, file));
+				fs.rmSync(path.join(types_dir, file), { force: true, recursive: true });
 			}
 		}
 	}
@@ -186,7 +187,10 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 	const outdir = path.join(config.kit.outDir, 'types', routes_dir, route.id);
 
 	// now generate new types
-	const imports = ["import type * as Kit from '@sveltejs/kit';"];
+	const imports = [
+		"import type * as Kit from '@sveltejs/kit';",
+		"import { MatcherParam } from '@sveltejs/kit/params';"
+	];
 
 	/** @type {string[]} */
 	const declarations = [];
@@ -198,11 +202,6 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 	// Makes sure a type is "repackaged" and therefore more readable
 	declarations.push('type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;');
 
-	// returns the predicate of a matcher's type guard - or string if there is no type guard
-	declarations.push(
-		'type MatcherParam<M> = M extends (param : string) => param is (infer U extends string) ? U : string;'
-	);
-
 	declarations.push(
 		'type RouteParams = ' + generate_params_type(route.params, outdir, config) + ';'
 	);
@@ -236,7 +235,10 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 			'type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;',
 
 			// Re-export `Snapshot` from @sveltejs/kit — in future we could use this to infer <T> from the return type of `snapshot.capture`
-			'export type Snapshot<T = any> = Kit.Snapshot<T>;'
+			'/** @deprecated Use the `snapshot` helper from `$app/navigation` instead. */',
+			'export type Snapshot<T = any> = Kit.Snapshot<T>;',
+
+			'export type ErrorProps = { error: App.Error };'
 		);
 	}
 
@@ -268,15 +270,8 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 
 		if (route.leaf.server) {
 			exports.push(
-				'export type Action<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Action<RouteParams, OutputData, RouteId>'
-			);
-			exports.push(
-				'export type Actions<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Actions<RouteParams, OutputData, RouteId>'
-			);
-		}
-
-		if (route.leaf.server) {
-			exports.push(
+				'export type Action<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Action<RouteParams, OutputData, RouteId>',
+				'export type Actions<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Actions<RouteParams, OutputData, RouteId>',
 				'export type PageProps = { params: RouteParams; data: PageData; form: ActionData }'
 			);
 		} else {
@@ -288,7 +283,9 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 		let all_pages_have_load = true;
 		/** @type {import('types').RouteParam[]} */
 		const layout_params = [];
-		const ids = ['RouteId'];
+		// a layout can live in a directory that has no `+page` of its own, in which case its own id
+		// is never the matched route — a request to a colocated `+server` doesn't execute layouts
+		const ids = is_page_route(route) ? ['RouteId'] : [];
 
 		route.layout.child_pages?.forEach((page) => {
 			const leaf = routes.get(page);
@@ -322,7 +319,7 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 			ids.push('null');
 		}
 
-		declarations.push(`type LayoutRouteId = ${ids.join(' | ')}`);
+		declarations.push(`type LayoutRouteId = ${ids.join(' | ') || 'never'}`);
 
 		declarations.push(
 			'type LayoutParams = RouteParams & ' + generate_params_type(layout_params, outdir, config)
@@ -437,7 +434,7 @@ function process_node(node, outdir, is_page, proxies, root, all_pages_have_load
 					'type ExtractActionFailure<T> = T extends Kit.ActionFailure<infer X>	? X extends void ? never : X : never;',
 					'type ActionsFailure<T extends Record<string, (...args: any) => any>> = { [Key in keyof T]: Exclude<ExtractActionFailure<Awaited<ReturnType<T[Key]>>>, void>; }[keyof T];',
 					`type ActionsExport = typeof import('${from}').actions`,
-					'export type SubmitFunction = Kit.SubmitFunction<Expand<ActionsSuccess<ActionsExport>>, Expand<ActionsFailure<ActionsExport>>>'
+					"export type SubmitFunction = import('$app/forms').SubmitFunction<Expand<ActionsSuccess<ActionsExport>>, Expand<ActionsFailure<ActionsExport>>>"
 				);
 
 				type = 'Expand<Kit.AwaitedActions<ActionsExport>> | null';
@@ -604,16 +601,22 @@ function replace_ext_with_js(file_path) {
  * @param {import('types').ValidatedConfig} config
  */
 function generate_params_type(params, outdir, config) {
-	/** @param {string} matcher */
-	const path_to_matcher = (matcher) =>
-		posixify(path.relative(outdir, path.join(config.kit.files.params, matcher + '.js')));
+	const path_to_params = () => {
+		const params_file =
+			resolve_entry(config.kit.files.params) ??
+			config.kit.files.params.replace(/\.(js|ts)$/, '') + '.js';
+
+		return posixify(path.relative(outdir, params_file));
+	};
+
+	const params_import = path_to_params();
 
 	return `{ ${params
 		.map(
 			(param) =>
-				`${param.name}${param.optional ? '?' : ''}: ${
+				`${/^\w+$/.test(param.name) ? param.name : `'${param.name}'`}${param.optional ? '?' : ''}: ${
 					param.matcher
-						? `MatcherParam<typeof import('${path_to_matcher(param.matcher)}').match>`
+						? `MatcherParam<(typeof import('${params_import}').params)[${JSON.stringify(param.matcher)}]>`
 						: 'string'
 				}${param.optional ? ' | undefined' : ''}`
 		)
@@ -642,6 +645,16 @@ export function tweak_types(content, is_server) {
 		const code = new MagicString(content);
 
 		const exports = new Map();
+		/** @param {import('typescript').BindingName} name */
+		function add_export(name) {
+			if (ts.isIdentifier(name)) {
+				if (names.has(name.text)) exports.set(name.text, name.text);
+			} else {
+				for (const element of name.elements) {
+					if (ts.isBindingElement(element)) add_export(element.name);
+				}
+			}
+		}
 
 		ast.forEachChild((node) => {
 			if (
@@ -668,9 +681,7 @@ export function tweak_types(content, is_server) {
 
 				if (ts.isVariableStatement(node)) {
 					node.declarationList.declarations.forEach((declaration) => {
-						if (ts.isIdentifier(declaration.name) && names.has(declaration.name.text)) {
-							exports.set(declaration.name.text, declaration.name.text);
-						}
+						add_export(declaration.name);
 					});
 				}
 			}
@@ -713,6 +724,62 @@ export function tweak_types(content, is_server) {
 			return _modified;
 		}
 
+		/**
+		 * @param {number} name_end position of the identifier the annotation is attached to
+		 * @param {import('typescript').TypeNode} type_node
+		 * @returns {string} the removed annotation's text
+		 */
+		function strip_type_annotation(name_end, type_node) {
+			let a = type_node.pos;
+			const b = type_node.end;
+			while (is_whitespace(content[a])) a += 1;
+
+			const type = content.slice(a, b);
+			code.remove(name_end, type_node.end);
+			modified = true;
+			return type;
+		}
+
+		/**
+		 * Types the first parameter of an untyped arrow/function expression.
+		 * @param {import('typescript').Expression | undefined} rhs
+		 * @param {string} type
+		 * @returns {boolean} `false` if there was nothing to annotate
+		 */
+		function annotate_first_param(rhs, type) {
+			if (
+				!rhs ||
+				!(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) ||
+				!rhs.parameters.length
+			) {
+				return false;
+			}
+
+			const arg = rhs.parameters[0];
+			const add_parens = content[arg.pos - 1] !== '(';
+
+			if (add_parens) code.prependRight(arg.pos, '(');
+
+			if (arg.type) return false;
+
+			code.appendLeft(arg.name.end, `: ${type}` + (add_parens ? ')' : ''));
+			return true;
+		}
+
+		/**
+		 * @param {import('typescript').Expression | undefined} initializer
+		 * @param {(prop: import('typescript').PropertyAssignment) => void} callback
+		 */
+		function for_each_action(initializer, callback) {
+			if (initializer && ts.isObjectLiteralExpression(initializer)) {
+				for (const prop of initializer.properties) {
+					if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+						callback(prop);
+					}
+				}
+			}
+		}
+
 		ast.forEachChild((node) => {
 			if (ts.isFunctionDeclaration(node) && node.name?.text && node.name?.text === 'load') {
 				// remove JSDoc comment above `export function load ...`
@@ -738,42 +805,13 @@ export function tweak_types(content, is_server) {
 						// edge case — remove JSDoc comment above individual export
 						replace_jsdoc_type_tags(declaration, declaration.initializer);
 
-						// remove type from `export const load: Load ...`
 						if (declaration.type) {
-							let a = declaration.type.pos;
-							const b = declaration.type.end;
-							while (is_whitespace(content[a])) a += 1;
+							const type = strip_type_annotation(declaration.name.end, declaration.type);
 
-							const type = content.slice(a, b);
-							code.remove(declaration.name.end, declaration.type.end);
-
-							const rhs = declaration.initializer;
-
-							if (
-								rhs &&
-								(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
-								rhs.parameters.length
-							) {
-								const arg = rhs.parameters[0];
-								const add_parens = content[arg.pos - 1] !== '(';
-
-								if (add_parens) code.prependRight(arg.pos, '(');
-
-								if (arg && !arg.type) {
-									code.appendLeft(
-										arg.name.end,
-										`: Parameters<${type}>[0]` + (add_parens ? ')' : '')
-									);
-								} else {
-									// prevent "type X is imported but not used" (isn't silenced by @ts-nocheck) when svelte-check runs
-									code.append(`;null as any as ${type};`);
-								}
-							} else {
+							if (!annotate_first_param(declaration.initializer, `Parameters<${type}>[0]`)) {
 								// prevent "type X is imported but not used" (isn't silenced by @ts-nocheck) when svelte-check runs
 								code.append(`;null as any as ${type};`);
 							}
-
-							modified = true;
 						}
 					} else if (
 						is_server &&
@@ -785,69 +823,34 @@ export function tweak_types(content, is_server) {
 						const removed = replace_jsdoc_type_tags(node, declaration.initializer);
 						// ... and move type to each individual action
 						if (removed) {
-							const rhs = declaration.initializer;
-							if (ts.isObjectLiteralExpression(rhs)) {
-								for (const prop of rhs.properties) {
-									if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-										const rhs = prop.initializer;
-										const replaced = replace_jsdoc_type_tags(prop, rhs);
-										if (
-											!replaced &&
-											rhs &&
-											(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
-											rhs.parameters?.[0]
-										) {
-											const name = ts.isIdentifier(rhs.parameters[0].name)
-												? rhs.parameters[0].name.text
-												: 'event';
-											code.prependRight(
-												rhs.pos,
-												`/** @param {import('./$types').RequestEvent} ${name} */ `
-											);
-										}
-									}
+							for_each_action(declaration.initializer, (prop) => {
+								const rhs = prop.initializer;
+								const replaced = replace_jsdoc_type_tags(prop, rhs);
+								if (
+									!replaced &&
+									rhs &&
+									(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
+									rhs.parameters?.[0]
+								) {
+									const name = ts.isIdentifier(rhs.parameters[0].name)
+										? rhs.parameters[0].name.text
+										: 'event';
+									code.prependRight(
+										rhs.pos,
+										`/** @param {import('./$types').RequestEvent} ${name} */ `
+									);
 								}
-							}
+							});
 						}
 
-						// remove type from `export const actions: Actions ...`
 						if (declaration.type) {
-							let a = declaration.type.pos;
-							const b = declaration.type.end;
-							while (is_whitespace(content[a])) a += 1;
-
-							const type = content.slice(a, b);
-							code.remove(declaration.name.end, declaration.type.end);
+							const type = strip_type_annotation(declaration.name.end, declaration.type);
 							code.append(`;null as any as ${type};`);
-							modified = true;
 
 							// ... and move type to each individual action
-							const rhs = declaration.initializer;
-							if (ts.isObjectLiteralExpression(rhs)) {
-								for (const prop of rhs.properties) {
-									if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-										const rhs = prop.initializer;
-
-										if (
-											rhs &&
-											(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
-											rhs.parameters.length
-										) {
-											const arg = rhs.parameters[0];
-											const add_parens = content[arg.pos - 1] !== '(';
-
-											if (add_parens) code.prependRight(arg.pos, '(');
-
-											if (arg && !arg.type) {
-												code.appendLeft(
-													arg.name.end,
-													": import('./$types').RequestEvent" + (add_parens ? ')' : '')
-												);
-											}
-										}
-									}
-								}
-							}
+							for_each_action(declaration.initializer, (prop) => {
+								annotate_first_param(prop.initializer, "import('./$types').RequestEvent");
+							});
 						}
 					}
 				}

package/src/core/utils.js

@@ -7,7 +7,7 @@ import { noop } from '../utils/functions.js';
 import { posixify } from '../utils/os.js';
 
 /**
- * Resolved path of the `runtime` directory
+ * Resolved path of the `runtime` directory posix-ified
  *
  * TODO Windows issue:
  * Vite or sth else somehow sets the driver letter inconsistently to lower or upper case depending on the run environment.
@@ -25,23 +25,48 @@ export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', im
  */
 export function get_runtime_base(root) {
 	return runtime_directory.startsWith(root)
-		? `/${path.relative(root, runtime_directory)}`
+		? `/${posixify(path.relative(root, runtime_directory))}`
 		: to_fs(runtime_directory);
 }
 
 /** @param {{ verbose: boolean }} opts */
-export function logger({ verbose }) {
+export function logger({ verbose } = { verbose: true }) {
 	/** @type {import('types').Logger} */
-	const log = (msg) => console.log(msg.replace(/^/gm, '  '));
+	const log = (msg) => console.log(msg);
 
 	/** @param {string} msg */
-	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
+	const err = (msg) => console.error(msg);
 
 	log.success = (msg) => log(styleText('green', `✔ ${msg}`));
 	log.error = (msg) => err(styleText(['bold', 'red'], msg));
 	log.warn = (msg) => log(styleText(['bold', 'yellow'], msg));
 	log.minor = verbose ? (msg) => log(styleText('grey', msg)) : noop;
 	log.info = verbose ? log : noop;
+	log.err = err;
+
+	log.prettyError = (error, caller) => {
+		/** @type {unknown} */
+		let e = error;
+
+		while (e instanceof Error) {
+			let stack = e.stack;
+			if (stack) {
+				if (caller) {
+					const i = stack.indexOf(caller);
+					// Cut the stack trace off at the point when our internal one starts
+					stack = stack.slice(0, stack.lastIndexOf('\n', i));
+				}
+
+				err(stack);
+			}
+
+			e = e.cause;
+		}
+
+		if (e) {
+			err(String(e));
+		}
+	};
 
 	return log;
 }

package/src/exports/env/index.js

@@ -0,0 +1,77 @@
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/** @import { DefinedEnvVars, EnvVarConfig } from '@sveltejs/kit/env' */
+
+/**
+ * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),
+ * which are made available via `$app/env/public` and `$app/env/private`.
+ *
+ * @example
+ * ```js
+ * import { defineEnvVars } from '@sveltejs/kit/env';
+ * import * as v from 'valibot';
+ *
+ * export const variables = defineEnvVars({
+ * 	API_URL: {
+ * 		schema: v.pipe(v.string(), v.url())
+ * 	},
+ * 	PORT: {
+ * 		schema: (value) => {
+ * 			if (value === undefined) return 3000;
+ * 			const port = Number(value);
+ * 			if (!Number.isInteger(port)) throw new Error('PORT must be an integer');
+ * 			return port;
+ * 		}
+ * 	}
+ * });
+ * ```
+ *
+ * @template {Record<string, EnvVarConfig<any>>} T
+ * @param {T} variables
+ * @returns {DefinedEnvVars<T>}
+ */
+export function defineEnvVars(variables) {
+	/** @type {Record<string, EnvVarConfig<any>>} */
+	const normalized = {};
+
+	for (const [name, config] of Object.entries(variables)) {
+		// standard schemas can be callable (e.g. ArkType), so a function is only a validator if it isn't one
+		normalized[name] =
+			typeof config.schema === 'function' && !('~standard' in config.schema)
+				? { ...config, schema: normalize_env_schema(config.schema) }
+				: config;
+	}
+
+	return /** @type {DefinedEnvVars<T>} */ (normalized);
+}
+
+/**
+ * @param {(value: string | undefined) => any} fn
+ * @returns {StandardSchemaV1<string | undefined, any>}
+ */
+function normalize_env_schema(fn) {
+	return /** @type {StandardSchemaV1<string | undefined, any>} */ (
+		/** @type {unknown} */ ({
+			'~standard': {
+				validate(/** @type {unknown} */ value) {
+					let result;
+
+					try {
+						result = fn(/** @type {string | undefined} */ (value));
+					} catch (error) {
+						return {
+							issues: [
+								{
+									message: error instanceof Error ? error.message || 'Invalid value' : String(error)
+								}
+							]
+						};
+					}
+
+					if (result instanceof Promise) return result; // will be rejected upstream
+
+					return { value: result };
+				}
+			}
+		})
+	);
+}

package/src/exports/env/public.d.ts

@@ -0,0 +1,55 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+export * from './index.js';
+
+/**
+ * [Environment variables](https://svelte.dev/docs/kit/environment-variables) can be configured by exporting
+ * a `variables` object from `src/env.ts`, using [`defineEnvVars`](https://svelte.dev/docs/kit/@sveltejs-kit-env#defineEnvVars).
+ */
+export interface EnvVarConfig<T> {
+	/**
+	 * Whether the environment variable can be accessed by client-side code.
+	 * - if `true`, it can be imported from `$app/env/public`
+	 * - if `false`, it can be imported from `$app/env/private`, which is a [server-only module](https://svelte.dev/docs/kit/server-only-modules)
+	 * @default false
+	 */
+	public?: boolean;
+	/**
+	 * Whether the value is determined at build time or when the app runs.
+	 * - if `true`, the build time value is inlined into the bundle. This enables optimisations like dead-code elimination
+	 * - if `false`, the value is read from the environment when the app starts
+	 * @default false
+	 */
+	static?: boolean;
+	/**
+	 * A [Standard Schema](https://standardschema.dev/) validator that is applied to the value when the app starts.
+	 * Alternatively, a function that returns the (possibly transformed) value, or throws an error explaining
+	 * the problem. Returning `undefined` is valid, so a function can describe an optional variable.
+	 * The validator can output any value — not necessarily a string — but public, non-static values must be
+	 * serializable by [devalue](https://github.com/sveltejs/devalue) so that they can be sent to the browser.
+	 *
+	 * If omitted, the value must be set, but may be an empty string.
+	 */
+	schema?: StandardSchemaV1<string | undefined, T> | ((value: string | undefined) => T | undefined);
+	/**
+	 * A description of the variable that will be used for inline documentation on hover.
+	 */
+	description?: string;
+}
+
+/**
+ * The return type of [`defineEnvVars`](https://svelte.dev/docs/kit/@sveltejs-kit-env#defineEnvVars).
+ */
+export type DefinedEnvVars<T extends Record<string, EnvVarConfig<any>>> = {
+	readonly [K in keyof T]: EnvVarEntry<T[K]>;
+};
+
+/**
+ * Normalizes an environment variable config's schema (standard schema or function) to standard schema.
+ */
+type EnvVarEntry<C extends EnvVarConfig<any>> =
+	C['schema'] extends StandardSchemaV1<any, any>
+		? C
+		: C['schema'] extends (value: any) => infer R
+			? Omit<C, 'schema'> & { schema: StandardSchemaV1<string | undefined, R> }
+			: C;

package/src/exports/hooks/index.js

@@ -1,14 +1,8 @@
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
-
 export { sequence } from './sequence.js';
 
 /**
- * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),
- * which are made available via `$app/env/public` and `$app/env/private`.
- * @template {Record<string, EnvVarConfig<any>>} T
- * @param {T} variables
- * @returns {T}
+ * @internal
  */
-export function defineEnvVars(variables) {
-	return variables;
+export function defineEnvVars() {
+	throw new Error(`\`defineEnvVars\` has moved — import it from \`@sveltejs/kit/env\` instead`);
 }