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

package/src/core/config/index.js

@@ -1,13 +1,70 @@
-/** @import { Config } from '@sveltejs/kit' */
+/** @import { Config } from '@sveltejs/kit/vite' */
 /** @import { ValidatedConfig } from 'types' */
 /** @import { ResolvedConfig } from 'vite' */
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import * as url from 'node:url';
-import options from './options.js';
+import { styleText } from 'node:util';
+import { validate_options, kit_options, kit_experimental_options } from './options.js';
 import { resolve_entry } from '../../utils/filesystem.js';
 import { import_peer } from '../../utils/import.js';
+import { stackless } from '../../utils/error.js';
+
+/**
+ * Splits the config passed to the `sveltekit` Vite plugin into the options that
+ * SvelteKit processes itself and the options that are forwarded to
+ * `vite-plugin-svelte`. SvelteKit makes no assumptions about which options
+ * `vite-plugin-svelte` accepts — it plucks out its own options and passes
+ * everything else along (`vite-plugin-svelte` does its own validation).
+ * @param {Config} config
+ * @returns {{ svelte_config: Config, vite_plugin_svelte_config: Record<string, any> }}
+ */
+export function split_config(config) {
+	/** @type {Config} */
+	const svelte_config = {};
+
+	/** @type {Record<string, any>} */
+	const vite_plugin_svelte_config = {};
+
+	for (const key in config) {
+		if (key === 'experimental') {
+			// `experimental` is a namespace that both SvelteKit and vite-plugin-svelte
+			// use, so pluck out the flags SvelteKit recognises and pass the rest along
+			const experimental = /** @type {Record<string, any>} */ (config[key]) ?? {};
+
+			/** @type {Record<string, any>} */
+			const kit_experimental = {};
+			/** @type {Record<string, any>} */
+			const vps_experimental = {};
+
+			for (const flag in experimental) {
+				if (kit_experimental_options.includes(flag)) {
+					kit_experimental[flag] = experimental[flag];
+				} else {
+					vps_experimental[flag] = experimental[flag];
+				}
+			}
+
+			if (Object.keys(kit_experimental).length > 0) {
+				svelte_config.experimental = kit_experimental;
+			}
+			if (Object.keys(vps_experimental).length > 0) {
+				vite_plugin_svelte_config.experimental = vps_experimental;
+			}
+		} else if (kit_options.includes(key)) {
+			// @ts-expect-error - we've verified this is one of SvelteKit's own options
+			svelte_config[key] = config[key];
+		} else {
+			vite_plugin_svelte_config[key] = /** @type {Record<string, any>} */ (config)[key];
+		}
+	}
+
+	return {
+		svelte_config,
+		vite_plugin_svelte_config
+	};
+}
 
 /**
  * Loads the template (src/app.html by default) and validates that it has the
@@ -15,8 +72,8 @@ import { import_peer } from '../../utils/import.js';
  * @param {string} cwd
  * @param {ValidatedConfig} config
  */
-export function load_template(cwd, { kit }) {
-	const { files } = kit;
+export function load_template(cwd, config) {
+	const { files } = config;
 
 	const relative = path.relative(cwd, files.appTemplate);
 
@@ -42,11 +99,11 @@ export function load_template(cwd, { kit }) {
  * @param {ValidatedConfig} config
  */
 export function load_error_page(config) {
-	let { errorTemplate } = config.kit.files;
+	let { errorTemplate } = config.files;
 
 	// Don't do this inside resolving the config, because that would mean
 	// adding/removing error.html isn't detected and would require a restart.
-	if (!fs.existsSync(config.kit.files.errorTemplate)) {
+	if (!fs.existsSync(config.files.errorTemplate)) {
 		errorTemplate = url.fileURLToPath(new URL('./default-error.html', import.meta.url));
 	}
 
@@ -55,13 +112,12 @@ export function load_error_page(config) {
 
 /**
  * @param {string} [config]
+ * @param {typeof import('vite')} [vite]
  */
-export async function load_vite_config(config) {
-	const { resolveConfig } = /** @type {import('vite')} */ (
-		await import_peer('vite', process.cwd())
-	);
+export async function load_vite_config(config, vite) {
+	vite ??= /** @type {typeof import('vite')} */ (await import_peer('vite', process.cwd()));
 
-	return resolveConfig({ configFile: config }, 'build', process.env.MODE ?? 'production');
+	return vite.resolveConfig({ configFile: config }, 'build', process.env.MODE ?? 'production');
 }
 
 /**
@@ -70,98 +126,96 @@ export async function load_vite_config(config) {
  */
 export function extract_svelte_config(vite_config) {
 	const plugin = vite_config.plugins.find((p) => p.name === 'vite-plugin-sveltekit-setup');
-	return plugin?.api.options ?? process_config({});
+	return plugin?.api.options ?? process_config(validate_config({}), vite_config.root);
 }
 
 /**
- * @param {Config} config
+ * @param {ValidatedConfig} config
+ * @param {string} cwd
  * @returns {ValidatedConfig}
  */
-export function process_config(config, { cwd = process.cwd(), source = 'svelte.config.js' } = {}) {
-	try {
-		const validated = validate_config(config, cwd);
-
-		validated.kit.outDir = path.resolve(cwd, validated.kit.outDir);
+export function process_config(config, cwd) {
+	if (
+		config.csp?.directives?.['require-trusted-types-for']?.includes('script') &&
+		config.serviceWorker.register &&
+		resolve_entry(path.resolve(cwd, config.files.serviceWorker)) &&
+		!config.csp?.directives?.['trusted-types']?.includes('sveltekit-trusted-url')
+	) {
+		throw new Error(
+			"The `csp.directives['trusted-types']` option must include 'sveltekit-trusted-url' when `serviceWorker.register` is true"
+		);
+	}
 
-		for (const key in validated.kit.files) {
-			if (key === 'hooks') {
-				validated.kit.files.hooks.client = path.resolve(cwd, validated.kit.files.hooks.client);
-				validated.kit.files.hooks.server = path.resolve(cwd, validated.kit.files.hooks.server);
-				validated.kit.files.hooks.universal = path.resolve(
-					cwd,
-					validated.kit.files.hooks.universal
-				);
-			} else {
-				// @ts-expect-error
-				validated.kit.files[key] = path.resolve(cwd, validated.kit.files[key]);
-			}
+	config.outDir = path.resolve(cwd, config.outDir);
+	config.env.dir = path.resolve(cwd, config.env.dir);
+
+	for (const key in config.files) {
+		if (key === 'hooks') {
+			config.files.hooks.client = path.resolve(cwd, config.files.hooks.client);
+			config.files.hooks.server = path.resolve(cwd, config.files.hooks.server);
+			config.files.hooks.universal = path.resolve(cwd, config.files.hooks.universal);
+		} else if (key !== 'lib' /* TODO remove when we remove the `lib` option altogether */) {
+			// @ts-expect-error
+			config.files[key] = path.resolve(cwd, config.files[key]);
 		}
-
-		return validated;
-	} catch (e) {
-		const error = /** @type {Error} */ (e);
-
-		// redact the stack trace — it's not helpful to users
-		error.stack = `Error loading ${source}: ${error.message}\n`;
-		throw error;
 	}
+
+	return config;
 }
 
 /**
  * @param {Config} config
- * @param {string} [cwd]
  * @returns {ValidatedConfig}
  */
-export function validate_config(config, cwd = process.cwd()) {
-	if (typeof config !== 'object') {
-		throw new Error(
-			'The Svelte config file must have a configuration object as its default export. See https://svelte.dev/docs/kit/configuration'
-		);
-	}
-
-	/** @type {ValidatedConfig} */
-	const validated = options(config, 'config');
-	const files = validated.kit.files;
-
-	files.hooks.client ??= path.join(files.src, 'hooks.client');
-	files.hooks.server ??= path.join(files.src, 'hooks.server');
-	files.hooks.universal ??= path.join(files.src, 'hooks');
-	files.lib ??= path.join(files.src, 'lib');
-	files.params ??= path.join(files.src, 'params');
-	files.routes ??= path.join(files.src, 'routes');
-	files.serviceWorker ??= path.join(files.src, 'service-worker');
-	files.appTemplate ??= path.join(files.src, 'app.html');
-	files.errorTemplate ??= path.join(files.src, 'error.html');
-
-	if (validated.kit.router.resolution === 'server') {
-		if (validated.kit.router.type === 'hash') {
-			throw new Error(
-				"The `router.resolution` option cannot be 'server' if `router.type` is 'hash'"
-			);
-		}
-		if (validated.kit.output.bundleStrategy !== 'split') {
+export function validate_config(config) {
+	try {
+		if (typeof config !== 'object') {
 			throw new Error(
-				"The `router.resolution` option cannot be 'server' if `output.bundleStrategy` is 'inline' or 'single'"
+				'The SvelteKit options from the Vite config must be an object. See https://svelte.dev/docs/kit/configuration'
 			);
 		}
-	}
 
-	if (validated.kit.csp?.directives?.['require-trusted-types-for']?.includes('script')) {
-		if (!validated.kit.csp?.directives?.['trusted-types']?.includes('svelte-trusted-html')) {
-			throw new Error(
-				"The `csp.directives['trusted-types']` option must include 'svelte-trusted-html'"
-			);
+		const validated = validate_options(config, 'config');
+		const files = validated.files;
+
+		files.hooks.client ??= path.join(files.src, 'hooks.client');
+		files.hooks.server ??= path.join(files.src, 'hooks.server');
+		files.hooks.universal ??= path.join(files.src, 'hooks');
+		files.params ??= path.join(files.src, 'params');
+		files.routes ??= path.join(files.src, 'routes');
+		files.serviceWorker ??= path.join(files.src, 'service-worker');
+		files.appTemplate ??= path.join(files.src, 'app.html');
+		files.errorTemplate ??= path.join(files.src, 'error.html');
+
+		if (validated.router.resolution === 'server') {
+			if (validated.router.type === 'hash') {
+				throw new Error(
+					"The `router.resolution` option cannot be 'server' if `router.type` is 'hash'"
+				);
+			}
+			if (validated.output.bundleStrategy !== 'split') {
+				throw new Error(
+					"The `router.resolution` option cannot be 'server' if `output.bundleStrategy` is 'inline' or 'single'"
+				);
+			}
 		}
+
 		if (
-			validated.kit.serviceWorker?.register &&
-			resolve_entry(path.resolve(cwd, validated.kit.files.serviceWorker)) &&
-			!validated.kit.csp?.directives?.['trusted-types']?.includes('sveltekit-trusted-url')
+			validated.csp?.directives?.['require-trusted-types-for']?.includes('script') &&
+			!validated.csp?.directives?.['trusted-types']?.includes('svelte-trusted-html')
 		) {
 			throw new Error(
-				"The `csp.directives['trusted-types']` option must include 'sveltekit-trusted-url' when `serviceWorker.register` is true"
+				"The `csp.directives['trusted-types']` option must include 'svelte-trusted-html'"
 			);
 		}
-	}
 
-	return validated;
+		return validated;
+	} catch (e) {
+		const error = /** @type {Error} */ (e);
+
+		// Print a nicer version of the error to the console
+		console.log(styleText(['bold', 'red'], `\n${error.message}\n`));
+
+		throw stackless('Failed to load SvelteKit options from Vite config');
+	}
 }