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

package/src/core/sync/write_server.js

@@ -1,11 +1,10 @@
 import path from 'node:path';
-import { styleText } from 'node:util';
 import { hash } from '../../utils/hash.js';
 import { resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { s } from '../../utils/misc.js';
 import { load_error_page, load_template } from '../config/index.js';
-import { write_if_changed } from './utils.js';
+import { check_spelling, write_if_changed } from './utils.js';
 import { escape_html } from '../../utils/escape.js';
 
 /**
@@ -15,7 +14,6 @@ import { escape_html } from '../../utils/escape.js';
  *   config: import('types').ValidatedConfig;
  *   has_service_worker: boolean;
  *   template: string;
- *   error_page: string;
  * }} opts
  */
 const server_template = ({
@@ -23,18 +21,15 @@ const server_template = ({
 	server_hooks,
 	universal_hooks,
 	has_service_worker,
-	template,
-	error_page
+	template
 }) => `
-import root from '../root.js';
 import { set_building, set_prerendering } from '$app/env/internal';
 import { set_assets } from '$app/paths/internal/server';
-import { set_manifest, set_read_implementation } from '__sveltekit/server';
-import { set_env } from '__sveltekit/env';
+import { set_fix_stack_trace, set_manifest, set_read_implementation, log_response } from '__sveltekit/server';
+import error from '../shared/error-template.js';
 
 export const options = {
 	app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
-	async: ${s(!!config.compilerOptions?.experimental?.async)},
 	csp: ${s(config.kit.csp)},
 	csrf_check_origin: ${s(!config.kit.csrf.trustedOrigins.includes('*'))},
 	csrf_trusted_origins: ${s(config.kit.csrf.trustedOrigins)},
@@ -42,10 +37,9 @@ export const options = {
 	hash_routing: ${s(config.kit.router.type === 'hash')},
 	hooks: null, // added lazily, via \`get_hooks\`
 	link_header_preload: ${s(config.kit.output.linkHeaderPreload)},
-	root,
+	paths_origin: ${s(config.kit.paths.origin)},
 	service_worker: ${has_service_worker},
 	service_worker_options: ${config.kit.serviceWorker.register ? s(config.kit.serviceWorker.options) : 'null'},
-	server_error_boundaries: ${s(!!config.kit.experimental.handleRenderingErrors)},
 	templates: {
 		app: ({ head, body, assets, nonce, env }) => ${s(template)
 			.replace('%sveltekit.head%', '" + head + "')
@@ -57,10 +51,9 @@ export const options = {
 				/%sveltekit\.env\.([^%]+)%/g,
 				(_match, capture) => `" + (env[${s(capture)}] ?? "") + "`
 			)},
-		error: ({ status, message }) => ${s(error_page)
-			.replace(/%sveltekit\.status%/g, '" + status + "')
-			.replace(/%sveltekit\.error\.message%/g, '" + message + "')}
+		error
 	},
+	version: ${s(config.kit.version.name)},
 	version_hash: ${s(hash(config.kit.version.name))}
 };
 
@@ -68,9 +61,8 @@ export async function get_hooks() {
 	let handle;
 	let handleFetch;
 	let handleError;
-	let handleValidationError;
 	let init;
-	${server_hooks ? `({ handle, handleFetch, handleError, handleValidationError, init } = await import(${s(server_hooks)}));` : ''}
+	${server_hooks ? `({ handle, handleFetch, handleError, init } = await import(${s(server_hooks)}));` : ''}
 
 	let reroute;
 	let transport;
@@ -80,20 +72,15 @@ export async function get_hooks() {
 		handle,
 		handleFetch,
 		handleError,
-		handleValidationError,
 		init,
 		reroute,
 		transport
 	};
 }
 
-export { set_assets, set_building, set_env, set_manifest, set_prerendering, set_read_implementation };
+export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation, log_response };
 `;
 
-// TODO need to re-run this whenever src/app.html or src/error.html are
-// created or changed, or src/service-worker.js is created or deleted.
-// Also, need to check that updating hooks.server.js works
-
 /**
  * Write server configuration to disk
  * @param {import('types').ValidatedConfig} config
@@ -104,15 +91,14 @@ export function write_server(config, output, root) {
 	const server_hooks_file = resolve_entry(config.kit.files.hooks.server);
 	const universal_hooks_file = resolve_entry(config.kit.files.hooks.universal);
 
-	const typo = resolve_entry('src/+hooks.server');
-	if (typo) {
-		console.log(
-			styleText(
-				['bold', 'yellow'],
-				`Unexpected + prefix. Did you mean ${typo.split('/').at(-1)?.slice(1)}?` +
-					` at ${path.resolve(typo)}`
-			)
-		);
+	if (!server_hooks_file) {
+		check_spelling('src/hooks.server', 'src/+hooks.server', 'Unexpected + prefix');
+		check_spelling('src/hooks.server', 'src/hook.server', 'Missing s suffix');
+	}
+
+	if (!universal_hooks_file) {
+		check_spelling('src/hooks', 'src/+hooks', 'Unexpected + prefix');
+		check_spelling('src/hooks', 'src/hook', 'Missing s suffix');
 	}
 
 	/** @param {string} file */
@@ -120,6 +106,13 @@ export function write_server(config, output, root) {
 		return posixify(path.relative(`${output}/server`, file));
 	}
 
+	write_if_changed(
+		`${output}/shared/error-template.js`,
+		`export default ({ status, message }) => ${s(load_error_page(config))
+			.replace(/%sveltekit\.status%/g, '" + status + "')
+			.replace(/%sveltekit\.error\.message%/g, '" + message + "')};`
+	);
+
 	// Contains the stringified version of
 	/** @type {import('types').SSROptions} */
 	write_if_changed(
@@ -130,8 +123,7 @@ export function write_server(config, output, root) {
 			universal_hooks: universal_hooks_file ? relative(universal_hooks_file) : null,
 			has_service_worker:
 				config.kit.serviceWorker.register && !!resolve_entry(config.kit.files.serviceWorker),
-			template: load_template(root, config),
-			error_page: load_error_page(config)
+			template: load_template(root, config)
 		})
 	);
 }

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

@@ -0,0 +1,274 @@
+/** @import { ValidatedKitConfig } from 'types' */
+import process from 'node:process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { styleText } from 'node:util';
+import { write_if_changed } from '../utils.js';
+import {
+	ESSENTIAL_OPTIONS,
+	normalize_config,
+	RECOMMENDED_OPTIONS,
+	remove_trailing_slashstar
+} from './utils.js';
+import { extends_id, validate_resolved_config } from './validate.js';
+
+/** @type {typeof import('typescript')} */
+let ts;
+try {
+	ts = await import('typescript');
+} catch {
+	// The user has not installed TypeScript.
+}
+
+/**
+ * Generates the tsconfig that the user's tsconfig inherits from.
+ * @param {import('types').ValidatedKitConfig} kit
+ * @param {string} root
+ */
+export function write_tsconfig(kit, root) {
+	const paths = get_paths(kit, root);
+	const types = ['$app/types'];
+
+	write_parent_tsconfig(
+		root,
+		'$app/tsconfig',
+		{
+			compilerOptions: {
+				paths,
+				rootDirs: ['.', `${kit.outDir}/types`],
+				types,
+
+				// This is required for svelte-package to work as expected
+				// Can be overwritten
+				lib: ['ESNext', 'DOM', 'DOM.Iterable'],
+
+				...ESSENTIAL_OPTIONS,
+				...RECOMMENDED_OPTIONS
+			}
+		},
+		kit.typescript.config
+	);
+
+	validate_config(root, {
+		paths,
+		types,
+		exclusions: [kit.files.serviceWorker],
+		example: {
+			extends: '$app/tsconfig'
+		}
+	});
+
+	write_parent_tsconfig(root, '$app/tsconfig/service-worker', {
+		compilerOptions: {
+			paths,
+			types,
+			lib: ['ESNext', 'WebWorker'],
+			...ESSENTIAL_OPTIONS,
+			...RECOMMENDED_OPTIONS
+		}
+	});
+
+	validate_config(kit.files.serviceWorker, {
+		paths,
+		types,
+		example: {
+			extends: '$app/tsconfig/service-worker'
+		}
+	});
+}
+
+/**
+ * Write a generated `tsconfig.json` inside `node_modules`, for the
+ * user config to extend
+ * @param {string} root The project root
+ * @param {string} id The id of the generated config
+ * @param {any} config The contents of the generated tsconfig, with paths relative to `root`
+ * @param {ValidatedKitConfig['typescript']['config']} [transform] TODO get rid of this
+ */
+function write_parent_tsconfig(root, id, config, transform) {
+	// simplified tsconfig resolvers (e.g. Playwright's) only find `${id}.json`, not `${id}/tsconfig.json`
+	const out_file = path.join(root, `node_modules/${id}.json`);
+
+	let normalized = normalize_config(out_file, config);
+	normalized = transform?.(normalized) ?? normalized;
+
+	write_if_changed(out_file, JSON.stringify(normalized, null, '\t'));
+}
+
+/**
+ * @param {string} dir The directory to resolve a user config from
+ * @param {Object} options
+ * @param {Record<string, string[]>} options.paths The expected paths
+ * @param {string[]} options.types The expected types
+ * @param {string[]} [options.exclusions] Files that should be excluded
+ * @param {any} options.example What to print if the user config does _not_ extend the generated config
+ */
+function validate_config(dir, options) {
+	if (!ts) {
+		// The user has not installed TypeScript. Skip validation of config.
+		return;
+	}
+
+	const user_config = load_user_tsconfig(dir);
+	if (!user_config || !modified_since_last_check(user_config.file)) return;
+
+	// now that we've written the parent config, we can resolve the
+	// user config and validate that nothing important was overwritten
+	if (!extends_id(user_config.options, options.example.extends)) {
+		console.warn(
+			styleText(
+				['bold', 'yellow'],
+				`${path.relative(process.cwd(), user_config.file)} should extend SvelteKit's built-in configuration:`
+			)
+		);
+
+		console.warn(JSON.stringify(options.example, null, '  '));
+
+		return;
+	}
+
+	const resolved = ts.parseJsonConfigFileContent(user_config.options, ts.sys, dir);
+
+	const warnings = validate_resolved_config(
+		dir,
+		resolved,
+		options.paths,
+		options.types,
+		options.exclusions
+	);
+
+	if (warnings.length > 0) {
+		console.warn(
+			styleText(
+				['bold', 'yellow'],
+				`Found issues while validating ${path.relative(process.cwd(), user_config.file)}`
+			)
+		);
+
+		for (const warning of warnings) {
+			console.warn(`  - ${warning}`);
+		}
+	}
+}
+
+/** @type {Map<string, number>} */
+const mtimes = new Map();
+
+/**
+ * Returns true if the file was modified since we last got here,
+ * otherwise we can skip warnings
+ * @param {string} file
+ */
+function modified_since_last_check(file) {
+	const a = mtimes.get(file) ?? -1;
+	const b = fs.statSync(file).mtimeMs;
+	mtimes.set(file, b);
+
+	return b > a;
+}
+
+/**
+ * @param {string} cwd
+ * @param {string} file
+ */
+function maybe_file(cwd, file) {
+	const resolved = path.resolve(cwd, file);
+	if (fs.existsSync(resolved)) {
+		return resolved;
+	}
+}
+
+/** @param {string} cwd */
+function load_user_tsconfig(cwd) {
+	const file = maybe_file(cwd, 'tsconfig.json') || maybe_file(cwd, 'jsconfig.json');
+	if (!file) return;
+
+	const options = load_tsconfig(file);
+
+	return {
+		file,
+		kind: path.basename(file),
+		options
+	};
+}
+
+/**
+ * @param {string} file
+ */
+function load_tsconfig(file) {
+	const options = ts.readConfigFile(file, ts.sys.readFile);
+
+	if (options.error) {
+		let message = `Failed to parse TypeScript config`;
+
+		if (typeof options.error.messageText === 'string') {
+			message += `: ${options.error.messageText}`;
+		}
+
+		const error = new Error(message);
+		error.stack = '';
+
+		if (options.error.file && options.error.start !== undefined) {
+			const line_start = options.error.file.text.lastIndexOf('\n', options.error.start);
+
+			const line =
+				line_start === -1
+					? 0
+					: options.error.file.text.slice(0, options.error.start).split('\n').length;
+			const column = options.error.start - line_start;
+
+			error.stack = `${error.message}\n    at ${path.relative(process.cwd(), file)}:${line}:${column}`;
+		}
+
+		throw error;
+	}
+
+	return options.config;
+}
+
+/** Matches anything (except the empty string/string with newline), and separates any trailing `/*` */
+const alias_key = /^(.+?)(\/\*)?$/;
+
+/** Matches anything (except the empty string/string with newline), and separates any trailing `/*` or file extension */
+const alias_value = /^(.+?)((\/\*)|(\.\w+))?$/;
+
+/**
+ * Generates tsconfig path aliases from kit's aliases and the package.json `imports` field.
+ * Related to vite alias creation.
+ *
+ * @param {import('types').ValidatedKitConfig} config
+ * @param {string} root
+ * @returns {Record<string, string[]>}
+ */
+function get_paths(config, root) {
+	const alias = {
+		...config.alias
+	};
+
+	/** @type {Record<string, string[]>} */
+	const paths = {};
+
+	for (const [key, value] of Object.entries(alias)) {
+		const key_match = alias_key.exec(key);
+		if (!key_match) throw new Error(`Invalid alias key: ${key}`);
+
+		const value_match = alias_value.exec(value);
+		if (!value_match) throw new Error(`Invalid alias value: ${value}`);
+
+		const resolved = path.resolve(root, remove_trailing_slashstar(value));
+		const slashstar = key_match[2];
+
+		if (slashstar) {
+			paths[key] = [resolved + '/*'];
+		} else {
+			paths[key] = [resolved];
+			const fileending = value_match[4];
+
+			if (!fileending && !(key + '/*' in alias)) {
+				paths[key + '/*'] = [resolved + '/*'];
+			}
+		}
+	}
+
+	return paths;
+}

package/src/core/sync/write_tsconfig/test-app/package.json

@@ -0,0 +1,7 @@
+{
+	"private": true,
+	"imports": {
+		"#lib": "./src/lib",
+		"#lib/*": "./src/lib/*"
+	}
+}

package/src/core/sync/write_tsconfig/utils.js

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { posixify } from '../../../utils/os.js';
+
+/**
+ * Without these, compilation will fail
+ * @type {Record<string, any>}
+ */
+export const ESSENTIAL_OPTIONS = {
+	// svelte-preprocess cannot figure out whether you have a value or a type, so tell TypeScript
+	// to enforce using \`import type\` instead of \`import\` for Types.
+	// Also, TypeScript doesn't know about import usages in the template because it only sees the
+	// script of a Svelte file. Therefore preserve all value imports.
+	verbatimModuleSyntax: true,
+	// Vite compiles modules one at a time
+	isolatedModules: true
+};
+
+/**
+ * Options that are strongly recommended, either because not having them is silly or
+ * because the align TypeScript's behaviour with Vite's, but which can be overwritten
+ * @type {Record<string, any>}
+ */
+export const RECOMMENDED_OPTIONS = {
+	allowJs: true,
+	checkJs: true,
+	forceConsistentCasingInFileNames: true,
+	resolveJsonModule: true,
+	moduleDetection: 'force',
+	moduleResolution: 'bundler',
+	allowImportingTsExtensions: true,
+	module: 'esnext',
+	target: 'esnext',
+	skipLibCheck: true,
+	esModuleInterop: true,
+	noEmit: true // prevent tsconfig error "overwriting input files" - Vite handles the build and ignores this
+};
+
+/**
+ * Makes paths relative to the output file
+ * @param {string} out
+ * @param {any} config
+ * @param {(input: any) => any} [transform] TODO get rid of this option
+ */
+export function normalize_config(out, config, transform) {
+	const dir = path.dirname(out);
+	const relative = (/** @type {string} */ file) => posixify(path.relative(dir, file));
+
+	const paths =
+		config.compilerOptions?.paths &&
+		Object.fromEntries(
+			Object.entries(config.compilerOptions?.paths).map(([k, v]) => [k, v.map(relative)])
+		);
+
+	const normalized = {
+		...config,
+		compilerOptions: {
+			...config.compilerOptions,
+			paths,
+			rootDirs: config.compilerOptions?.rootDirs?.map(relative)
+		},
+		include: config.include?.map(relative),
+		exclude: config.exclude?.map(relative)
+	};
+
+	return transform?.(normalized) ?? normalized;
+}
+
+/**
+ * @param {string} file
+ */
+export function remove_trailing_slashstar(file) {
+	if (file.endsWith('/*')) {
+		return file.slice(0, -2);
+	} else {
+		return file;
+	}
+}

package/src/core/sync/write_tsconfig/validate.js

@@ -0,0 +1,128 @@
+/** @import ts from 'typescript' */
+import path from 'node:path';
+import { ESSENTIAL_OPTIONS, remove_trailing_slashstar } from './utils.js';
+import { posixify } from '../../../utils/os.js';
+
+const formatter = new Intl.ListFormat('en-gb', { type: 'conjunction' });
+
+/**
+ * @param {string[]} things
+ */
+function join(things) {
+	return formatter.format(things.map((thing) => JSON.stringify(thing)));
+}
+
+/**
+ * @param {string} dir
+ * @param {ts.ParsedCommandLine} resolved
+ * @param {Record<string, string[]>} paths
+ * @param {string[]} types
+ * @param {string[]} [exclusions]
+ */
+export function validate_resolved_config(dir, resolved, paths, types, exclusions) {
+	/** @type {string[]} */
+	const warnings = [];
+
+	if (resolved.options.types) {
+		validate_types(warnings, types, resolved.options.types);
+	}
+
+	if (resolved.options.paths) {
+		validate_paths(
+			warnings,
+			/** @type {string} */ (resolved.options.pathsBasePath),
+			paths,
+			resolved.options.paths
+		);
+	}
+
+	if (exclusions) {
+		validate_exclusions(warnings, dir, exclusions, resolved.fileNames);
+	}
+
+	for (const key in ESSENTIAL_OPTIONS) {
+		if (resolved.options[key] !== ESSENTIAL_OPTIONS[key]) {
+			warnings.push(
+				`"${key}" was overwritten. It should be ${JSON.stringify(ESSENTIAL_OPTIONS[key])}`
+			);
+		}
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string[]} expected
+ * @param {string[]} actual
+ */
+export function validate_types(warnings, expected, actual) {
+	const missing_types = expected.filter((/** @type {string} */ type) => !actual.includes(type));
+
+	if (missing_types.length > 0) {
+		warnings.push(`"types" was overwritten. It must include ${join(missing_types)}`);
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string} base
+ * @param {Record<string, string[]>} expected
+ * @param {ts.MapLike<string[]>} actual
+ */
+export function validate_paths(warnings, base, expected, actual) {
+	/** @type {Set<string>} */
+	const mismatch = new Set();
+
+	for (const [k, e] of Object.entries(expected)) {
+		const a = actual[k]?.map((/** @type {string} */ x) =>
+			path.resolve(/** @type {string} */ (base), x)
+		);
+
+		if (JSON.stringify(e) !== JSON.stringify(a)) {
+			mismatch.add(remove_trailing_slashstar(k));
+		}
+	}
+
+	if (mismatch.size > 0) {
+		const joined = join([...mismatch]);
+
+		warnings.push(`"paths" was overwritten. Imports from ${joined} may not typecheck`);
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string[]} warnings
+ * @param {string} dir
+ * @param {string[]} exclusions
+ * @param {string[]} files
+ */
+export function validate_exclusions(warnings, dir, exclusions, files) {
+	const missing_exclusions = exclusions.map(posixify).filter((exclusion) => {
+		return files.some(
+			(f) => f === exclusion || f.startsWith(exclusion + '/') || f.startsWith(exclusion + '.')
+		);
+	});
+
+	if (missing_exclusions.length > 0) {
+		warnings.push(
+			`${join(missing_exclusions.map((file) => posixify(path.relative(dir, file))))} should be added to the "exclude" array`
+		);
+	}
+
+	return warnings;
+}
+
+/**
+ * Validates that a tsconfig contains `"extends": "<id>"`
+ * @param {any} options
+ * @param {string} id
+ */
+export function extends_id(options, id) {
+	const o = options.extends;
+	return Array.isArray(o) ? o.includes(id) : o === id;
+}