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

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

@@ -0,0 +1,274 @@
+/** @import { ValidatedConfig } 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 {ValidatedConfig} 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 {ValidatedConfig['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').ValidatedConfig} 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;
+}