@sveltejs/kit 1.0.0-next.39 → 1.0.0-next.390

package/dist/cli.js

@@ -1,546 +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 { pathToFileURL, resolve as resolve$1 } from 'url';
-import path from 'path';
+import 'path';
+import 'url';
 
-let FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM, isTTY=true;
-if (typeof process !== 'undefined') {
-	({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env);
-	isTTY = process.stdout && process.stdout.isTTY;
-}
-
-const $ = {
-	enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== 'dumb' && (
-		FORCE_COLOR != null && FORCE_COLOR !== '0' || isTTY
-	),
-
-	// modifiers
-	reset: init(0, 0),
-	bold: init(1, 22),
-	dim: init(2, 22),
-	italic: init(3, 23),
-	underline: init(4, 24),
-	inverse: init(7, 27),
-	hidden: init(8, 28),
-	strikethrough: init(9, 29),
-
-	// colors
-	black: init(30, 39),
-	red: init(31, 39),
-	green: init(32, 39),
-	yellow: init(33, 39),
-	blue: init(34, 39),
-	magenta: init(35, 39),
-	cyan: init(36, 39),
-	white: init(37, 39),
-	gray: init(90, 39),
-	grey: init(90, 39),
-
-	// background colors
-	bgBlack: init(40, 49),
-	bgRed: init(41, 49),
-	bgGreen: init(42, 49),
-	bgYellow: init(43, 49),
-	bgBlue: init(44, 49),
-	bgMagenta: init(45, 49),
-	bgCyan: init(46, 49),
-	bgWhite: init(47, 49)
-};
-
-function run(arr, str) {
-	let i=0, tmp, beg='', end='';
-	for (; i < arr.length; i++) {
-		tmp = arr[i];
-		beg += tmp.open;
-		end += tmp.close;
-		if (!!~str.indexOf(tmp.close)) {
-			str = str.replace(tmp.rgx, tmp.close + tmp.open);
-		}
-	}
-	return beg + str + end;
-}
-
-function chain(has, keys) {
-	let ctx = { has, keys };
-
-	ctx.reset = $.reset.bind(ctx);
-	ctx.bold = $.bold.bind(ctx);
-	ctx.dim = $.dim.bind(ctx);
-	ctx.italic = $.italic.bind(ctx);
-	ctx.underline = $.underline.bind(ctx);
-	ctx.inverse = $.inverse.bind(ctx);
-	ctx.hidden = $.hidden.bind(ctx);
-	ctx.strikethrough = $.strikethrough.bind(ctx);
-
-	ctx.black = $.black.bind(ctx);
-	ctx.red = $.red.bind(ctx);
-	ctx.green = $.green.bind(ctx);
-	ctx.yellow = $.yellow.bind(ctx);
-	ctx.blue = $.blue.bind(ctx);
-	ctx.magenta = $.magenta.bind(ctx);
-	ctx.cyan = $.cyan.bind(ctx);
-	ctx.white = $.white.bind(ctx);
-	ctx.gray = $.gray.bind(ctx);
-	ctx.grey = $.grey.bind(ctx);
-
-	ctx.bgBlack = $.bgBlack.bind(ctx);
-	ctx.bgRed = $.bgRed.bind(ctx);
-	ctx.bgGreen = $.bgGreen.bind(ctx);
-	ctx.bgYellow = $.bgYellow.bind(ctx);
-	ctx.bgBlue = $.bgBlue.bind(ctx);
-	ctx.bgMagenta = $.bgMagenta.bind(ctx);
-	ctx.bgCyan = $.bgCyan.bind(ctx);
-	ctx.bgWhite = $.bgWhite.bind(ctx);
-
-	return ctx;
-}
-
-function init(open, close) {
-	let blk = {
-		open: `\x1b[${open}m`,
-		close: `\x1b[${close}m`,
-		rgx: new RegExp(`\\x1b\\[${close}m`, 'g')
-	};
-	return function (txt) {
-		if (this !== void 0 && this.has !== void 0) {
-			!!~this.has.indexOf(open) || (this.has.push(open),this.keys.push(blk));
-			return txt === void 0 ? this : $.enabled ? run(this.keys, txt+'') : txt+'';
-		}
-		return txt === void 0 ? chain([open], [blk]) : $.enabled ? run([blk], txt+'') : txt+'';
-	};
-}
-
-const noop = () => {};
-
-/** @typedef {import('./types').ConfigDefinition} ConfigDefinition */
-
-/** @type {Record<string, ConfigDefinition>} */
-const options = {
-	compilerOptions: {
-		type: 'leaf',
-		default: null,
-		validate: noop
-	},
-
-	extensions: {
-		type: 'leaf',
-		default: ['.svelte'],
-		validate: (option, keypath) => {
-			if (!Array.isArray(option) || !option.every((page) => typeof page === 'string')) {
-				throw new Error(`${keypath} must be an array of strings`);
-			}
-
-			option.forEach((extension) => {
-				if (extension[0] !== '.') {
-					throw new Error(`Each member of ${keypath} must start with '.' — saw '${extension}'`);
-				}
-
-				if (!/^(\.[a-z0-9]+)+$/i.test(extension)) {
-					throw new Error(`File extensions must be alphanumeric — saw '${extension}'`);
-				}
-			});
-
-			return option;
-		}
-	},
-
-	kit: {
-		type: 'branch',
-		children: {
-			adapter: {
-				type: 'leaf',
-				default: [null],
-				validate: (option, keypath) => {
-					// support both `adapter: 'foo'` and `adapter: ['foo', opts]`
-					if (!Array.isArray(option)) {
-						option = [option];
-					}
-
-					// TODO allow inline functions
-					assert_is_string(option[0], keypath);
-
-					return option;
-				}
-			},
+/** @param {unknown} e */
+function handle_error(e) {
+	const error = coalesce_to_error(e);
 
-			amp: expect_boolean(false),
+	if (error.name === 'SyntaxError') throw error;
 
-			appDir: expect_string('_app', false),
-
-			files: {
-				type: 'branch',
-				children: {
-					assets: expect_string('static'),
-					routes: expect_string('src/routes'),
-					serviceWorker: expect_string('src/service-worker'),
-					setup: expect_string('src/setup'),
-					template: expect_string('src/app.html')
-				}
-			},
-
-			host: expect_string(null),
-
-			hostHeader: expect_string(null),
-
-			paths: {
-				type: 'branch',
-				children: {
-					base: expect_string(''),
-					assets: expect_string('')
-				}
-			},
-
-			prerender: {
-				type: 'branch',
-				children: {
-					crawl: expect_boolean(true),
-					enabled: expect_boolean(true),
-					force: expect_boolean(false),
-					pages: {
-						type: 'leaf',
-						default: ['*'],
-						validate: (option, keypath) => {
-							if (!Array.isArray(option) || !option.every((page) => typeof page === 'string')) {
-								throw new Error(`${keypath} must be an array of strings`);
-							}
-
-							option.forEach((page) => {
-								if (page !== '*' && page[0] !== '/') {
-									throw new Error(
-										`Each member of ${keypath} must be either '*' or an absolute path beginning with '/' — saw '${page}'`
-									);
-								}
-							});
-
-							return option;
-						}
-					}
-				}
-			},
-
-			// used for testing
-			startGlobal: expect_string(null),
-
-			target: expect_string(null)
-		}
-	},
-
-	preprocess: {
-		type: 'leaf',
-		default: null,
-		validate: noop
-	}
-};
-
-/**
- * @param {string} string
- * @param {boolean} allow_empty
- * @returns {ConfigDefinition}
- */
-function expect_string(string, allow_empty = true) {
-	return {
-		type: 'leaf',
-		default: string,
-		validate: (option, keypath) => {
-			assert_is_string(option, keypath);
-			if (!allow_empty && option === '') {
-				throw new Error(`${keypath} cannot be empty`);
-			}
-			return option;
-		}
-	};
-}
-
-/**
- * @param {boolean} boolean
- * @returns {ConfigDefinition}
- */
-function expect_boolean(boolean) {
-	return {
-		type: 'leaf',
-		default: boolean,
-		validate: (option, keypath) => {
-			if (typeof option !== 'boolean') {
-				throw new Error(`${keypath} should be true or false, if specified`);
-			}
-			return option;
-		}
-	};
-}
-
-/**
- * @param {any} option
- * @param {string} keypath
- */
-function assert_is_string(option, keypath) {
-	if (typeof option !== 'string') {
-		throw new Error(`${keypath} should be a string, if specified`);
+	console.error($.bold().red(`> ${error.message}`));
+	if (error.stack) {
+		console.error($.gray(error.stack.split('\n').slice(1).join('\n')));
 	}
-}
-
-/** @typedef {import('./types').ConfigDefinition} ConfigDefinition */
-
-/**
- * @param {Record<string, ConfigDefinition>} definition
- * @param {any} option
- * @param {string} keypath
- * @returns {any}
- */
-function validate(definition, option, keypath) {
-	for (const key in option) {
-		if (!(key in definition)) {
-			let message = `Unexpected option ${keypath}.${key}`;
-
-			if (keypath === 'config' && key in options.kit) {
-				message += ` (did you mean config.kit.${key}?)`;
-			} else if (keypath === 'config.kit' && key in options) {
-				message += ` (did you mean config.${key}?)`;
-			}
-
-			throw new Error(message);
-		}
-	}
-
-	/** @type {Record<string, any>} */
-	const merged = {};
-
-	for (const key in definition) {
-		const expected = definition[key];
-		const actual = option[key];
-
-		const child_keypath = `${keypath}.${key}`;
-
-		if (key in option) {
-			if (expected.type === 'branch') {
-				if (actual && (typeof actual !== 'object' || Array.isArray(actual))) {
-					throw new Error(`${keypath}.${key} should be an object`);
-				}
 
-				merged[key] = validate(expected.children, actual, child_keypath);
-			} else {
-				merged[key] = expected.validate(actual, child_keypath);
-			}
-		} else {
-			merged[key] =
-				expected.type === 'branch'
-					? validate(expected.children, {}, child_keypath)
-					: expected.default;
-		}
-	}
-
-	return merged;
-}
-
-/**
- * @param {string} from
- * @param {string} to
- */
-function resolve(from, to) {
-	// the `/.` is weird, but allows `${assets}/images/blah.jpg` to work
-	// when `assets` is empty
-	return remove_trailing_slash(resolve$1(add_trailing_slash(from), to)) || '/.';
-}
-
-/**
- * @param {string} str
- */
-function add_trailing_slash(str) {
-	return str.endsWith('/') ? str : `${str}/`;
-}
-
-/**
- * @param {string} str
- */
-function remove_trailing_slash(str) {
-	return str.endsWith('/') ? str.slice(0, -1) : str;
-}
-
-async function load_config({ cwd = process.cwd() } = {}) {
-	const config_file = path.join(cwd, 'svelte.config.cjs');
-	const config = await import(pathToFileURL(config_file).href);
-	const validated = validate_config(config.default);
-
-	validated.kit.files.assets = path.resolve(cwd, validated.kit.files.assets);
-	validated.kit.files.routes = path.resolve(cwd, validated.kit.files.routes);
-	validated.kit.files.serviceWorker = path.resolve(cwd, validated.kit.files.serviceWorker);
-	validated.kit.files.setup = path.resolve(cwd, validated.kit.files.setup);
-	validated.kit.files.template = path.resolve(cwd, validated.kit.files.template);
-
-	// TODO check all the `files` exist when the config is loaded?
-	// TODO check that `target` is present in the provided template
-
-	return validated;
-}
-
-/**
- * @param {import('../../../types').Config} config
- * @returns {import('../../types.js').ValidatedConfig}
- */
-function validate_config(config) {
-	/** @type {import('../../types.js').ValidatedConfig} */
-	const validated = validate(options, config, 'config');
-
-	// resolve paths
-	const { paths } = validated.kit;
-
-	if (paths.base !== '' && !paths.base.startsWith('/')) {
-		throw new Error('config.kit.paths.base must be a root-relative path');
-	}
-
-	paths.assets = resolve(paths.base, paths.assets);
-
-	return validated;
-}
-
-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());
-	}
-
-	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';
-		}
-
-		console.error($.bold().red(message));
-		console.error($.grey(error.stack));
-		process.exit(1);
-	}
-}
-
-/** @param {Error} error */
-function handle_error(error) {
-	console.log($.bold().red(`> ${error.message}`));
-	console.log($.gray(error.stack));
 	process.exit(1);
 }
 
-/** @param {number} port */
-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('1.0.0-next.39');
+const prog = sade('svelte-kit').version('1.0.0-next.390');
 
 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('./chunks/index.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 });
+			const config = await load_config();
+			const packaging = await import('./chunks/index.js');
 
-			watcher.on('stdout', (data) => {
-				process.stdout.write(data);
-			});
-
-			watcher.on('stderr', (data) => {
-				process.stderr.write(data);
-			});
-
-			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')
-	.option('--verbose', 'Log more stuff', false)
-	.action(async ({ verbose }) => {
-		process.env.NODE_ENV = 'production';
-		const config = await get_config();
+	.command('sync')
+	.describe('Synchronise generated files')
+	.action(async () => {
+		if (!fs__default.existsSync('svelte.config.js')) {
+			console.warn('Missing svelte.config.js — skipping');
+			return;
+		}
 
 		try {
-			const { build } = await import('./chunks/index4.js');
-			await build(config);
-
-			console.log(`\nRun ${$.bold().cyan('npm start')} to try your app locally.`);
-
-			if (config.kit.adapter[0]) {
-				const { adapt } = await import('./chunks/index5.js');
-				await adapt(config, { verbose });
-			} else {
-				console.log($.bold().yellow('\nNo adapter specified'));
-
-				// prettier-ignore
-				console.log(
-					`See ${$.bold().cyan('https://kit.svelte.dev/docs#adapters')} to learn how to configure your app to run on the platform of your choosing`
-				);
-			}
+			const config = await load_config();
+			const sync = await import('./chunks/sync.js').then(function (n) { return n.d; });
+			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();
+// TODO remove for 1.0
+replace('dev');
+replace('build');
+replace('preview');
 
-		const { start } = await import('./chunks/index6.js');
+prog.parse(process.argv, { unknown: (arg) => `Unknown option: ${arg}` });
 
-		try {
-			await start({ port, config });
+/** @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)}`);
+			});
 
-			console.log($.bold().cyan(`> Listening on http://localhost:${port}`));
-			if (open) if (open) launch(port);
-		} catch (error) {
-			handle_error(error);
-		}
-	});
+			console.error(
+				`
+				${$.grey('// vite.config.js')}
+				import { sveltekit } from '@sveltejs/kit/vite';
 
-// For the benefit of early-adopters. Can later be removed
-prog
-	.command('adapt')
-	.describe('Customise your production build for different platforms')
-	.option('--verbose', 'Log more stuff', false)
-	.action(async () => {
-		console.log('"svelte-kit build" will now run the adapter');
-	});
+				/** @type {import('vite').UserConfig} */
+				const config = {
+					plugins: [sveltekit()]
+				};
 
-prog.parse(process.argv, { unknown: (arg) => `Unknown option: ${arg}` });
+				export default config;
 
-export { $ };
+				`.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 };