@sveltejs/kit 1.0.0-next.36 → 1.0.0-next.362

package/dist/chunks/write_tsconfig.js

@@ -0,0 +1,274 @@
+import fs__default from 'fs';
+import path__default from 'path';
+import { $ } from './error.js';
+
+/** @param {string} dir */
+function mkdirp(dir) {
+	try {
+		fs__default.mkdirSync(dir, { recursive: true });
+	} catch (/** @type {any} */ e) {
+		if (e.code === 'EEXIST') return;
+		throw e;
+	}
+}
+
+/** @param {string} path */
+function rimraf(path) {
+	fs__default.rmSync(path, { force: true, recursive: true });
+}
+
+/**
+ * @param {string} source
+ * @param {string} target
+ * @param {{
+ *   filter?: (basename: string) => boolean;
+ *   replace?: Record<string, string>;
+ * }} opts
+ */
+function copy(source, target, opts = {}) {
+	if (!fs__default.existsSync(source)) return [];
+
+	/** @type {string[]} */
+	const files = [];
+
+	const prefix = posixify(target) + '/';
+
+	const regex = opts.replace
+		? new RegExp(`\\b(${Object.keys(opts.replace).join('|')})\\b`, 'g')
+		: null;
+
+	/**
+	 * @param {string} from
+	 * @param {string} to
+	 */
+	function go(from, to) {
+		if (opts.filter && !opts.filter(path__default.basename(from))) return;
+
+		const stats = fs__default.statSync(from);
+
+		if (stats.isDirectory()) {
+			fs__default.readdirSync(from).forEach((file) => {
+				go(path__default.join(from, file), path__default.join(to, file));
+			});
+		} else {
+			mkdirp(path__default.dirname(to));
+
+			if (opts.replace) {
+				const data = fs__default.readFileSync(from, 'utf-8');
+				fs__default.writeFileSync(
+					to,
+					data.replace(
+						/** @type {RegExp} */ (regex),
+						(match, key) => /** @type {Record<string, string>} */ (opts.replace)[key]
+					)
+				);
+			} else {
+				fs__default.copyFileSync(from, to);
+			}
+
+			files.push(to === target ? posixify(path__default.basename(to)) : posixify(to).replace(prefix, ''));
+		}
+	}
+
+	go(source, target);
+
+	return files;
+}
+
+/**
+ * Get a list of all files in a directory
+ * @param {string} cwd - the directory to walk
+ * @param {boolean} [dirs] - whether to include directories in the result
+ */
+function walk(cwd, dirs = false) {
+	/** @type {string[]} */
+	const all_files = [];
+
+	/** @param {string} dir */
+	function walk_dir(dir) {
+		const files = fs__default.readdirSync(path__default.join(cwd, dir));
+
+		for (const file of files) {
+			const joined = path__default.join(dir, file);
+			const stats = fs__default.statSync(path__default.join(cwd, joined));
+			if (stats.isDirectory()) {
+				if (dirs) all_files.push(joined);
+				walk_dir(joined);
+			} else {
+				all_files.push(joined);
+			}
+		}
+	}
+
+	return walk_dir(''), all_files;
+}
+
+/** @param {string} str */
+function posixify(str) {
+	return str.replace(/\\/g, '/');
+}
+
+/** @type {Map<string, string>} */
+const previous_contents = new Map();
+
+/**
+ * @param {string} file
+ * @param {string} code
+ */
+function write_if_changed(file, code) {
+	if (code !== previous_contents.get(file)) {
+		write(file, code);
+	}
+}
+
+/**
+ * @param {string} file
+ * @param {string} code
+ */
+function write(file, code) {
+	previous_contents.set(file, code);
+	mkdirp(path__default.dirname(file));
+	fs__default.writeFileSync(file, code);
+}
+
+/** @param {string} str */
+function trim(str) {
+	const indentation = /** @type {RegExpExecArray} */ (/\n?(\s*)/.exec(str))[1];
+	const pattern = new RegExp(`^${indentation}`, 'gm');
+	return str.replace(pattern, '').trim();
+}
+
+/** @param {string} file */
+const exists = (file) => fs__default.existsSync(file) && file;
+
+/**
+ * Writes the tsconfig that the user's tsconfig inherits from.
+ * @param {import('types').ValidatedKitConfig} config
+ */
+function write_tsconfig(config, cwd = process.cwd()) {
+	const out = path__default.join(config.outDir, 'tsconfig.json');
+	const user_file =
+		exists(path__default.resolve(cwd, 'tsconfig.json')) || exists(path__default.resolve(cwd, 'jsconfig.json'));
+
+	if (user_file) validate(config, cwd, out, user_file);
+
+	/** @param {string} file */
+	const project_relative = (file) => posixify(path__default.relative('.', file));
+
+	/** @param {string} file */
+	const config_relative = (file) => posixify(path__default.relative(config.outDir, file));
+
+	const dirs = new Set([
+		project_relative(path__default.dirname(config.files.routes)),
+		project_relative(path__default.dirname(config.files.lib))
+	]);
+
+	/** @type {string[]} */
+	const include = [];
+	dirs.forEach((dir) => {
+		include.push(config_relative(`${dir}/**/*.js`));
+		include.push(config_relative(`${dir}/**/*.ts`));
+		include.push(config_relative(`${dir}/**/*.svelte`));
+	});
+
+	/** @type {Record<string, string[]>} */
+	const paths = {};
+	const alias = {
+		$lib: project_relative(config.files.lib),
+		...config.alias
+	};
+	for (const [key, value] of Object.entries(alias)) {
+		if (fs__default.existsSync(project_relative(value))) {
+			paths[key] = [project_relative(value)];
+			paths[key + '/*'] = [project_relative(value) + '/*'];
+		}
+	}
+
+	write_if_changed(
+		out,
+		JSON.stringify(
+			{
+				compilerOptions: {
+					// generated options
+					baseUrl: config_relative('.'),
+					paths,
+					rootDirs: [config_relative('.'), './types'],
+
+					// 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.
+					importsNotUsedAsValues: 'error',
+					// Vite compiles modules one at a time
+					isolatedModules: true,
+					// 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. Requires TS 4.5 or higher.
+					preserveValueImports: true,
+
+					// This is required for svelte-kit package to work as expected
+					// Can be overwritten
+					lib: ['esnext', 'DOM'],
+					moduleResolution: 'node',
+					module: 'esnext',
+					target: 'esnext'
+				},
+				include,
+				exclude: [config_relative('node_modules/**'), './**']
+			},
+			null,
+			'\t'
+		)
+	);
+}
+
+/**
+ * @param {import('types').ValidatedKitConfig} config
+ * @param {string} cwd
+ * @param {string} out
+ * @param {string} user_file
+ */
+function validate(config, cwd, out, user_file) {
+	// we have to eval the file, since it's not parseable as JSON (contains comments)
+	const user_tsconfig_json = fs__default.readFileSync(user_file, 'utf-8');
+	const user_tsconfig = (0, eval)(`(${user_tsconfig_json})`);
+
+	// we need to check that the user's tsconfig extends the framework config
+	const extend = user_tsconfig.extends;
+	const extends_framework_config = extend && path__default.resolve(cwd, extend) === out;
+
+	const kind = path__default.basename(user_file);
+
+	if (extends_framework_config) {
+		const { paths: user_paths } = user_tsconfig.compilerOptions || {};
+
+		if (user_paths && fs__default.existsSync(config.files.lib)) {
+			/** @type {string[]} */
+			const lib = user_paths['$lib'] || [];
+			/** @type {string[]} */
+			const lib_ = user_paths['$lib/*'] || [];
+
+			const missing_lib_paths =
+				!lib.some((relative) => path__default.resolve(cwd, relative) === config.files.lib) ||
+				!lib_.some((relative) => path__default.resolve(cwd, relative) === path__default.join(config.files.lib, '/*'));
+
+			if (missing_lib_paths) {
+				console.warn(
+					$
+						.bold()
+						.yellow(`Your compilerOptions.paths in ${kind} should include the following:`)
+				);
+				const relative = posixify(path__default.relative('.', config.files.lib));
+				console.warn(`{\n  "$lib":["${relative}"],\n  "$lib/*":["${relative}/*"]\n}`);
+			}
+		}
+	} else {
+		let relative = posixify(path__default.relative('.', out));
+		if (!relative.startsWith('./')) relative = './' + relative;
+
+		console.warn(
+			$.bold().yellow(`Your ${kind} should extend the configuration generated by SvelteKit:`)
+		);
+		console.warn(`{\n  "extends": "${relative}"\n}`);
+	}
+}
+
+export { write as a, write_tsconfig as b, copy as c, walk as d, mkdirp as m, posixify as p, rimraf as r, trim as t, write_if_changed as w };

package/dist/cli.js

@@ -1,151 +1,98 @@
-import { existsSync } from 'fs';
+import fs__default from 'fs';
+import { l as load_config, $, c as coalesce_to_error } from './chunks/error.js';
 import sade from 'sade';
-import { $, l as load_config } from './index.js';
-import 'url';
 import 'path';
+import 'url';
 
-var version = "1.0.0-next.36";
-
-async function get_config() {
-	// TODO this is temporary, for the benefit of early adopters
-	if (existsSync('snowpack.config.js') || existsSync('snowpack.config.cjs')) {
-		// prettier-ignore
-		console.error($.bold().red(
-			'SvelteKit now uses https://vitejs.dev. Please replace snowpack.config.js with vite.config.js:'
-		));
-
-		// prettier-ignore
-		console.error(`
-			import { resolve } from 'path';
-
-			export default {
-				resolve: {
-					alias: {
-						$components: resolve('src/components')
-					}
-				}
-			};
-		`.replace(/^\t{3}/gm, '').replace(/\t/gm, '  ').trim());
-	}
+/** @param {unknown} e */
+function handle_error(e) {
+	const error = coalesce_to_error(e);
 
-	try {
-		return await load_config();
-	} catch (error) {
-		let message = error.message;
-
-		if (error.code === 'MODULE_NOT_FOUND') {
-			if (existsSync('svelte.config.js')) {
-				// TODO this is temporary, for the benefit of early adopters
-				message =
-					'You must rename svelte.config.js to svelte.config.cjs, and snowpack.config.js to snowpack.config.cjs';
-			} else {
-				message = 'Missing svelte.config.cjs';
-			}
-		} else if (error.name === 'SyntaxError') {
-			message = 'Malformed svelte.config.cjs';
-		}
+	if (error.name === 'SyntaxError') throw error;
 
-		console.error($.bold().red(message));
-		console.error($.grey(error.stack));
-		process.exit(1);
+	console.error($.bold().red(`> ${error.message}`));
+	if (error.stack) {
+		console.error($.gray(error.stack.split('\n').slice(1).join('\n')));
 	}
-}
 
-function handle_error(error) {
-	console.log($.bold().red(`> ${error.message}`));
-	console.log($.gray(error.stack));
 	process.exit(1);
 }
 
-async function launch(port) {
-	const { exec } = await import('child_process');
-	exec(`${process.platform == 'win32' ? 'start' : 'open'} http://localhost:${port}`);
-}
-
-const prog = sade('svelte-kit').version(version);
+const prog = sade('svelte-kit').version('1.0.0-next.362');
 
 prog
-	.command('dev')
-	.describe('Start a development server')
-	.option('-p, --port', 'Port', 3000)
-	.option('-o, --open', 'Open a browser tab', false)
-	.action(async ({ port, open }) => {
-		process.env.NODE_ENV = 'development';
-		const config = await get_config();
-
-		const { dev } = await import('./index2.js');
-
+	.command('package')
+	.describe('Create a package')
+	.option('-w, --watch', 'Rerun when files change', false)
+	.action(async ({ watch }) => {
 		try {
-			const watcher = await dev({ port, config });
-
-			watcher.on('stdout', (data) => {
-				process.stdout.write(data);
-			});
-
-			watcher.on('stderr', (data) => {
-				process.stderr.write(data);
-			});
+			const config = await load_config();
+			const packaging = await import('./chunks/index.js');
 
-			console.log($.bold().cyan(`> Listening on http://localhost:${watcher.port}`));
-			if (open) launch(watcher.port);
+			await (watch ? packaging.watch(config) : packaging.build(config));
 		} catch (error) {
 			handle_error(error);
 		}
 	});
 
 prog
-	.command('build')
-	.describe('Create a production build of your app')
+	.command('sync')
+	.describe('Synchronise generated files')
 	.action(async () => {
-		process.env.NODE_ENV = 'production';
-		const config = await get_config();
-
-		const { build } = await import('./index3.js');
+		if (!fs__default.existsSync('svelte.config.js')) {
+			console.warn('Missing svelte.config.js — skipping');
+			return;
+		}
 
 		try {
-			await build(config);
+			const config = await load_config();
+			const sync = await import('./chunks/sync.js').then(function (n) { return n.c; });
+			sync.all(config);
 		} catch (error) {
 			handle_error(error);
 		}
 	});
 
-prog
-	.command('start')
-	.describe('Serve an already-built app')
-	.option('-p, --port', 'Port', 3000)
-	.option('-o, --open', 'Open a browser tab', false)
-	.action(async ({ port, open }) => {
-		process.env.NODE_ENV = 'production';
-		const config = await get_config();
-
-		const { start } = await import('./index4.js');
+// TODO remove for 1.0
+replace('dev');
+replace('build');
+replace('preview');
 
-		try {
-			await start({ port, config });
+prog.parse(process.argv, { unknown: (arg) => `Unknown option: ${arg}` });
 
-			console.log($.bold().cyan(`> Listening on http://localhost:${port}`));
-			if (open) if (open) launch(port);
-		} catch (error) {
-			handle_error(error);
-		}
-	});
+/** @param {string} command */
+function replace(command) {
+	prog
+		.command(command)
+		.describe(`No longer available — use vite ${command} instead`)
+		.action(async () => {
+			const message = `\n> svelte-kit ${command} is no longer available — use vite ${command} instead`;
+			console.error($.bold().red(message));
+
+			const steps = [
+				'Install vite as a devDependency with npm/pnpm/etc',
+				'Create a vite.config.js with the @sveltejs/kit/vite plugin (see below)',
+				`Update your package.json scripts to reference \`vite ${command}\` instead of \`svelte-kit ${command}\``
+			];
+
+			steps.forEach((step, i) => {
+				console.error(`  ${i + 1}. ${$.cyan(step)}`);
+			});
 
-prog
-	.command('adapt')
-	.describe('Customise your production build for different platforms')
-	.option('--verbose', 'Log more stuff', false)
-	.action(async ({ verbose }) => {
-		process.env.NODE_ENV = 'production';
-		const config = await get_config();
+			console.error(
+				`
+				${$.grey('// vite.config.js')}
+				import { sveltekit } from '@sveltejs/kit/vite';
 
-		const { adapt } = await import('./index6.js');
+				/** @type {import('vite').UserConfig} */
+				const config = {
+					plugins: [sveltekit()]
+				};
 
-		try {
-			await adapt(config, { verbose });
-		} catch (error) {
-			handle_error(error);
-		}
-	});
+				export default config;
 
-prog.parse(process.argv, { unknown: (arg) => `Unknown option: ${arg}` });
-//# sourceMappingURL=cli.js.map
+				`.replace(/^\t{4}/gm, '')
+			);
+			process.exit(1);
+		});
+}

package/dist/hooks.js

@@ -0,0 +1,28 @@
+/**
+ * @param {...import('types').Handle} handlers
+ * @returns {import('types').Handle}
+ */
+function sequence(...handlers) {
+	const length = handlers.length;
+	if (!length) return ({ event, resolve }) => resolve(event);
+
+	return ({ event, resolve }) => {
+		return apply_handle(0, event);
+
+		/**
+		 * @param {number} i
+		 * @param {import('types').RequestEvent} event
+		 * @returns {import('types').MaybePromise<Response>}
+		 */
+		function apply_handle(i, event) {
+			const handle = handlers[i];
+
+			return handle({
+				event,
+				resolve: i < length - 1 ? (event) => apply_handle(i + 1, event) : resolve
+			});
+		}
+	};
+}
+
+export { sequence };