@sveltejs/kit/dist/cli.js

import { existsSync } from 'fs';
import sade from 'sade';
import { pathToFileURL, resolve as resolve$1 } from 'url';
import path from 'path';

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;
				}
			},

			amp: expect_boolean(false),

			appDir: expect_string('_app', false),

			files: {
				type: 'branch',
				children: {
					assets: expect_string('static'),
					lib: expect_string('src/lib'),
					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`);
	}
}

/** @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.lib = path.resolve(cwd, validated.kit.files.lib);
	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(`
			// Consult https://vitejs.dev/config/ to learn about these options
			import { join } from 'path';
			import { readFileSync } from 'fs';
			import { cwd } from 'process';

			const pkg = JSON.parse(readFileSync(join(cwd(), 'package.json')));

			/** @type {import('vite').UserConfig} */
			export default {
				ssr: {
					noExternal: Object.keys(pkg.dependencies || {})
				}
			};

		`.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.48');

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');

		try {
			const watcher = await dev({ port, config });

			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);
		} 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();

		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`
				);
			}
		} 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('./chunks/index6.js');

		try {
			await start({ port, config });

			console.log($.bold().cyan(`> Listening on http://localhost:${port}`));
			if (open) if (open) launch(port);
		} catch (error) {
			handle_error(error);
		}
	});

// 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');
	});

prog.parse(process.argv, { unknown: (arg) => `Unknown option: ${arg}` });

export { $ };