@sveltejs/kit 1.0.0-next.316 → 1.0.0-next.319

package/assets/client/start.js

@@ -492,9 +492,6 @@ function create_client({ target, session, base, trailing_slash }) {
 	});
 	ready = true;
 
-	/** Keeps tracks of multiple navigations caused by redirects during rendering */
-	let navigating = 0;
-
 	let router_enabled = true;
 
 	// keeping track of the history index in order to prevent popstate navigation events if needed
@@ -529,9 +526,6 @@ function create_client({ target, session, base, trailing_slash }) {
 	/** @type {{}} */
 	let token;
 
-	/** @type {{}} */
-	let navigating_token;
-
 	/**
 	 * @param {string} href
 	 * @param {{ noscroll?: boolean; replaceState?: boolean; keepfocus?: boolean; state?: any }} opts
@@ -577,6 +571,7 @@ function create_client({ target, session, base, trailing_slash }) {
 	}
 
 	/**
+	 * Returns `true` if update completes, `false` if it is aborted
 	 * @param {URL} url
 	 * @param {string[]} redirect_chain
 	 * @param {boolean} no_cache
@@ -608,11 +603,11 @@ function create_client({ target, session, base, trailing_slash }) {
 
 		if (!navigation_result) {
 			await native_navigation(url);
-			return; // unnecessary, but TypeScript prefers it this way
+			return false; // unnecessary, but TypeScript prefers it this way
 		}
 
 		// abort if user navigated during update
-		if (token !== current_token) return;
+		if (token !== current_token) return false;
 
 		invalidated.length = 0;
 
@@ -634,7 +629,7 @@ function create_client({ target, session, base, trailing_slash }) {
 					await native_navigation(new URL(navigation_result.redirect, location.href));
 				}
 
-				return;
+				return false;
 			}
 		} else if (navigation_result.props?.page?.status >= 400) {
 			const updated = await stores.updated.check();
@@ -717,6 +712,8 @@ function create_client({ target, session, base, trailing_slash }) {
 
 		const leaf_node = navigation_result.state.branch[navigation_result.state.branch.length - 1];
 		router_enabled = leaf_node?.module.router !== false;
+
+		return true;
 	}
 
 	/** @param {import('./types').NavigationResult} result */
@@ -1269,10 +1266,6 @@ function create_client({ target, session, base, trailing_slash }) {
 
 		accepted();
 
-		navigating++;
-
-		const current_navigating_token = (navigating_token = {});
-
 		if (started) {
 			stores.navigating.set({
 				from: current.url,
@@ -1280,18 +1273,13 @@ function create_client({ target, session, base, trailing_slash }) {
 			});
 		}
 
-		await update(normalized, redirect_chain, false, {
+		const completed = await update(normalized, redirect_chain, false, {
 			scroll,
 			keepfocus,
 			details
 		});
 
-		navigating--;
-
-		// navigation was aborted
-		if (navigating_token !== current_navigating_token) return;
-
-		if (!navigating) {
+		if (completed) {
 			const navigation = { from, to: normalized };
 			callbacks.after_navigate.forEach((fn) => fn(navigation));
 
@@ -1484,11 +1472,6 @@ function create_client({ target, session, base, trailing_slash }) {
 				// Ignore if <a> has a target
 				if (is_svg_a_element ? a.target.baseVal : a.target) return;
 
-				if (url.href === location.href) {
-					if (!location.hash) event.preventDefault();
-					return;
-				}
-
 				// Check if new url only differs by hash and use the browser default behavior in that case
 				// This will ensure the `hashchange` event is fired
 				// Removing the hash does a full page navigation in the browser, so make sure a hash is present
@@ -1513,7 +1496,7 @@ function create_client({ target, session, base, trailing_slash }) {
 					redirect_chain: [],
 					details: {
 						state: {},
-						replaceState: false
+						replaceState: url.href === location.href
 					},
 					accepted: () => event.preventDefault(),
 					blocked: () => event.preventDefault()

package/dist/chunks/index4.js

@@ -42,11 +42,12 @@ function create_builder({ config, build_data, prerendered, log }) {
 		config,
 		prerendered,
 
-		createEntries(fn) {
+		async createEntries(fn) {
 			const { routes } = build_data.manifest_data;
 
 			/** @type {import('types').RouteDefinition[]} */
 			const facades = routes.map((route) => ({
+				id: route.id,
 				type: route.type,
 				segments: route.id.split('/').map((segment) => ({
 					dynamic: segment.includes('['),
@@ -90,7 +91,7 @@ function create_builder({ config, build_data, prerendered, log }) {
 				});
 
 				if (filtered.size > 0) {
-					complete({
+					await complete({
 						generateManifest: ({ relativePath, format }) =>
 							generate_manifest({
 								build_data,

package/dist/chunks/index6.js

@@ -1,8 +1,10 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { createRequire } from 'module';
+import { join, relative, dirname } from 'path';
 import { $ } from '../cli.js';
-import { r as rimraf, m as mkdirp, w as walk$1 } from './filesystem.js';
+import chokidar from 'chokidar';
+import { w as walk$1, m as mkdirp, p as posixify, r as rimraf, c as copy } from './filesystem.js';
+import { createRequire } from 'module';
 import 'sade';
 import 'child_process';
 import 'net';
@@ -15248,178 +15250,6 @@ async function preprocess(source, preprocessor, options) {
     return result.to_processed();
 }
 
-const essential_files = ['README', 'LICENSE', 'CHANGELOG', '.gitignore', '.npmignore'];
-
-/**
- * @param {import('types').ValidatedConfig} config
- * @param {string} cwd
- */
-async function make_package(config, cwd = process.cwd()) {
-	if (!fs.existsSync(config.kit.files.lib)) {
-		throw new Error(`${config.kit.files.lib} does not exist`);
-	}
-
-	const package_dir = path.isAbsolute(config.kit.package.dir)
-		? config.kit.package.dir
-		: path.join(cwd, config.kit.package.dir);
-	rimraf(package_dir);
-	mkdirp(package_dir); // TODO https://github.com/sveltejs/kit/issues/2333
-
-	if (config.kit.package.emitTypes) {
-		// Generate type definitions first so hand-written types can overwrite generated ones
-		await emit_dts(config);
-		// Resolve aliases, TS leaves them as-is
-		const files = walk$1(package_dir);
-		for (const file of files) {
-			const filename = path.join(package_dir, file);
-			const source = fs.readFileSync(filename, 'utf8');
-			fs.writeFileSync(filename, resolve_$lib_alias(file, source, config));
-		}
-	}
-
-	const files = walk$1(config.kit.files.lib);
-
-	const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
-
-	delete pkg.scripts;
-	pkg.type = 'module';
-
-	/** @type {Record<string, string>} */
-	const generated = { './package.json': './package.json' };
-
-	/** @type {Record<string, string>} */
-	const clashes = {};
-	let contains_svelte_files = false;
-
-	for (const file of files) {
-		const ext = path.extname(file);
-		const normalized = file.replace(/\\/g, '/');
-		const svelte_ext = config.extensions.find((ext) => file.endsWith(ext)); // unlike `ext`, could be e.g. `.svelte.md`
-
-		if (!config.kit.package.files(normalized)) {
-			const base = svelte_ext ? file : file.slice(0, -ext.length);
-			for (const e of ['.d.ts', '.d.mts', '.d.cts']) {
-				const dts_path = path.join(package_dir, base + e);
-				if (fs.existsSync(dts_path)) {
-					fs.unlinkSync(dts_path);
-
-					const dir = path.dirname(dts_path);
-					if (fs.readdirSync(dir).length === 0) {
-						fs.rmdirSync(dir);
-					}
-				}
-			}
-			continue;
-		}
-
-		const filename = path.join(config.kit.files.lib, file);
-		const source = fs.readFileSync(filename);
-
-		/** @type {string} */
-		let out_file;
-
-		/** @type {string | Buffer} */
-		let out_contents;
-
-		if (svelte_ext) {
-			// it's a Svelte component
-			contains_svelte_files = true;
-			out_file = file.slice(0, -svelte_ext.length) + '.svelte';
-			out_contents = source.toString('utf-8');
-			out_contents = config.preprocess
-				? strip_lang_tags((await preprocess(out_contents, config.preprocess, { filename })).code)
-				: out_contents;
-			out_contents = resolve_$lib_alias(out_file, out_contents, config);
-		} else if (ext === '.ts' && file.endsWith('.d.ts')) {
-			// TypeScript's declaration emit won't copy over the d.ts files, so we do it here
-			out_file = file;
-			out_contents = source.toString('utf-8');
-			out_contents = resolve_$lib_alias(out_file, out_contents, config);
-			if (fs.existsSync(path.join(package_dir, out_file))) {
-				console.warn(
-					'Found already existing file from d.ts generation for ' +
-						out_file +
-						'. This file will be overwritten.'
-				);
-			}
-		} else if (ext === '.ts') {
-			out_file = file.slice(0, -'.ts'.length) + '.js';
-			out_contents = await transpile_ts(filename, source.toString('utf-8'));
-			out_contents = resolve_$lib_alias(out_file, out_contents, config);
-		} else {
-			out_file = file;
-			out_contents = source;
-		}
-
-		write(path.join(package_dir, out_file), out_contents);
-
-		if (config.kit.package.exports(normalized)) {
-			const original = `$lib/${normalized}`;
-			const entry = `./${out_file.replace(/\\/g, '/')}`;
-			const key = entry.replace(/\/index\.js$|(\/[^/]+)\.js$/, '$1');
-
-			if (clashes[key]) {
-				throw new Error(
-					`Duplicate "${key}" export. Please remove or rename either ${clashes[key]} or ${original}`
-				);
-			}
-
-			generated[key] = entry;
-			clashes[key] = original;
-		}
-	}
-
-	pkg.exports = { ...generated, ...pkg.exports };
-
-	if (!pkg.svelte && contains_svelte_files) {
-		// Several heuristics in Kit/vite-plugin-svelte to tell Vite to mark Svelte packages
-		// rely on the "svelte" property. Vite/Rollup/Webpack plugin can all deal with it.
-		// See https://github.com/sveltejs/kit/issues/1959 for more info and related threads.
-		if (pkg.exports['.']) {
-			const svelte_export =
-				typeof pkg.exports['.'] === 'string'
-					? pkg.exports['.']
-					: pkg.exports['.'].import || pkg.exports['.'].default;
-			if (svelte_export) {
-				pkg.svelte = svelte_export;
-			} else {
-				console.warn(
-					'Cannot generate a "svelte" entry point because ' +
-						'the "." entry in "exports" is not a string. ' +
-						'If you set it by hand, please also set one of the options as a "svelte" entry point\n'
-				);
-			}
-		} else {
-			console.warn(
-				'Cannot generate a "svelte" entry point because ' +
-					'the "." entry in "exports" is missing. ' +
-					'Please specify one or set a "svelte" entry point yourself\n'
-			);
-		}
-	}
-
-	write(path.join(package_dir, 'package.json'), JSON.stringify(pkg, null, 2));
-
-	const whitelist = fs.readdirSync(cwd).filter((file) => {
-		const lowercased = file.toLowerCase();
-		return essential_files.some((name) => lowercased.startsWith(name.toLowerCase()));
-	});
-	for (const pathname of whitelist) {
-		const full_path = path.join(cwd, pathname);
-		if (fs.lstatSync(full_path).isDirectory()) continue; // just to be sure
-
-		const package_path = path.join(package_dir, pathname);
-		if (!fs.existsSync(package_path)) fs.copyFileSync(full_path, package_path);
-	}
-
-	const from = path.relative(cwd, config.kit.files.lib);
-	const to = path.relative(cwd, config.kit.package.dir);
-	console.log($.bold().green(`${from} -> ${to}`));
-	console.log(`Successfully built '${pkg.name}' package. To publish it to npm:`);
-	console.log($.bold().cyan(`  cd ${to}`));
-	console.log($.bold().cyan('  npm publish\n'));
-}
-
 /**
  * Resolves the `$lib` alias.
  *
@@ -15433,7 +15263,7 @@ async function make_package(config, cwd = process.cwd()) {
  * @param {import('types').ValidatedConfig} config
  * @returns {string}
  */
-function resolve_$lib_alias(file, content, config) {
+function resolve_lib_alias(file, content, config) {
 	/**
 	 * @param {string} match
 	 * @param {string} _
@@ -15446,7 +15276,7 @@ function resolve_$lib_alias(file, content, config) {
 
 		const full_path = path.join(config.kit.files.lib, file);
 		const full_import_path = path.join(config.kit.files.lib, import_path.slice('$lib/'.length));
-		let resolved = path.relative(path.dirname(full_path), full_import_path).replace(/\\/g, '/');
+		let resolved = posixify(path.relative(path.dirname(full_path), full_import_path));
 		resolved = resolved.startsWith('.') ? resolved : './' + resolved;
 		return match.replace(import_path, resolved);
 	};
@@ -15462,27 +15292,170 @@ function resolve_$lib_alias(file, content, config) {
  * @param {string} content
  */
 function strip_lang_tags(content) {
-	strip_lang_tag('script');
-	strip_lang_tag('style');
-	return content;
+	return content
+		.replace(/(<!--[^]*?-->)|(<script[^>]*?)\s(?:type|lang)=(["']).*?\3/g, '$1$2')
+		.replace(/(<!--[^]*?-->)|(<style[^>]*?)\s(?:type|lang)=(["']).*?\3/g, '$1$2');
+}
 
-	/**
-	 * @param {string} tagname
-	 */
-	function strip_lang_tag(tagname) {
-		const regexp = new RegExp(
-			`/<!--[^]*?-->|<${tagname}(\\s[^]*?)?(?:>([^]*?)<\\/${tagname}>|\\/>)`,
-			'g'
+/**
+ * @param {string} file
+ * @param {Parameters<typeof fs.writeFileSync>[1]} contents
+ */
+function write(file, contents) {
+	mkdirp(path.dirname(file));
+	fs.writeFileSync(file, contents);
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @returns {import('./types').File[]}
+ */
+function scan(config) {
+	return walk$1(config.kit.files.lib).map((file) => analyze(config, file));
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} file
+ * @returns {import('./types').File}
+ */
+function analyze(config, file) {
+	const name = posixify(file);
+
+	const svelte_extension = config.extensions.find((ext) => name.endsWith(ext));
+
+	const base = svelte_extension ? name : name.slice(0, -path.extname(name).length);
+
+	const dest = svelte_extension
+		? name.slice(0, -svelte_extension.length) + '.svelte'
+		: name.endsWith('.d.ts')
+		? name
+		: name.endsWith('.ts')
+		? name.slice(0, -3) + '.js'
+		: name;
+
+	return {
+		name,
+		dest,
+		base,
+		is_included: config.kit.package.files(name),
+		is_exported: config.kit.package.exports(name),
+		is_svelte: !!svelte_extension
+	};
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('./types').File[]} files
+ */
+function generate_pkg(cwd, files) {
+	const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+
+	delete pkg.scripts;
+	pkg.type = 'module';
+
+	pkg.exports = {
+		'./package.json': './package.json',
+		...pkg.exports
+	};
+
+	/** @type {Record<string, string>} */
+	const clashes = {};
+
+	for (const file of files) {
+		if (file.is_included && file.is_exported) {
+			const original = `$lib/${file.name}`;
+			const entry = `./${file.dest}`;
+			const key = entry.replace(/\/index\.js$|(\/[^/]+)\.js$/, '$1');
+
+			if (clashes[key]) {
+				throw new Error(
+					`Duplicate "${key}" export. Please remove or rename either ${clashes[key]} or ${original}`
+				);
+			}
+
+			if (!pkg.exports[key]) {
+				pkg.exports[key] = entry;
+			}
+
+			clashes[key] = original;
+		}
+	}
+
+	return pkg;
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} cwd
+ * @param {import('./types').File[]} files
+ */
+async function emit_dts(config, cwd, files) {
+	const tmp = `${config.kit.outDir}/package/types`;
+	rimraf(tmp);
+	mkdirp(tmp);
+
+	const require = createRequire(import.meta.url);
+	const emit = await try_load_svelte2tsx();
+	await emit({
+		libRoot: config.kit.files.lib,
+		svelteShimsPath: require.resolve('svelte2tsx/svelte-shims.d.ts'),
+		declarationDir: path.relative(cwd, tmp)
+	});
+
+	const handwritten = new Set();
+	const excluded = new Set();
+
+	// remove excluded files, and files that conflict with hand-written .d.ts
+	for (const file of files) {
+		if (file.name.endsWith('.d.ts')) {
+			handwritten.add(file.name);
+		}
+
+		if (!file.is_included) {
+			excluded.add(file.base + '.d.ts');
+			excluded.add(file.base + '.d.mts');
+			excluded.add(file.base + '.d.cts');
+		}
+	}
+
+	// resolve $lib alias (TODO others), copy into package dir
+	for (const file of walk$1(tmp)) {
+		const normalized = posixify(file);
+
+		if (handwritten.has(normalized)) {
+			console.warn(`Using $lib/${normalized} instead of generated .d.ts file`);
+		}
+
+		// don't overwrite hand-written .d.ts files
+		if (excluded.has(normalized)) continue;
+
+		const source = fs.readFileSync(path.join(tmp, normalized), 'utf8');
+		write(
+			path.join(config.kit.package.dir, normalized),
+			resolve_lib_alias(normalized, source, config)
+		);
+	}
+}
+
+async function try_load_svelte2tsx() {
+	const svelte2tsx = await load();
+	const emit_dts = svelte2tsx.emitDts;
+	if (!emit_dts) {
+		throw new Error(
+			'You need to install svelte2tsx >=0.4.1 if you want to generate type definitions'
 		);
-		content = content.replace(regexp, (tag, attributes) => {
-			if (!attributes) return tag;
-			const idx = tag.indexOf(attributes);
-			return (
-				tag.substring(0, idx) +
-				attributes.replace(/\s(type|lang)=(["']).*?\2/, ' ') +
-				tag.substring(idx + attributes.length)
+	}
+	return emit_dts;
+
+	async function load() {
+		try {
+			return await import('svelte2tsx');
+		} catch (e) {
+			throw new Error(
+				'You need svelte2tsx and typescript if you want to generate type definitions. Install it through your package manager, or disable generation which is highly discouraged. See https://kit.svelte.dev/docs/packaging'
 			);
-		});
+		}
 	}
 }
 
@@ -15513,14 +15486,32 @@ async function try_load_ts() {
  * @param {import('typescript')} ts
  */
 function load_tsconfig(filename, ts) {
-	const filedir = path.dirname(filename);
-	const tsconfig_filename = ts.findConfigFile(filedir, ts.sys.fileExists);
+	let config_filename;
+
+	// ts.findConfigFile is broken (it will favour a distant tsconfig
+	// over a near jsconfig, and then only when you call it twice)
+	// so we implement it ourselves
+	let dir = filename;
+	while (dir !== (dir = path.dirname(dir))) {
+		const tsconfig = path.join(dir, 'tsconfig.json');
+		const jsconfig = path.join(dir, 'jsconfig.json');
+
+		if (fs.existsSync(tsconfig)) {
+			config_filename = tsconfig;
+			break;
+		}
 
-	if (!tsconfig_filename) {
+		if (fs.existsSync(jsconfig)) {
+			config_filename = jsconfig;
+			break;
+		}
+	}
+
+	if (!config_filename) {
 		throw new Error('Failed to locate tsconfig or jsconfig');
 	}
 
-	const { error, config } = ts.readConfigFile(tsconfig_filename, ts.sys.readFile);
+	const { error, config } = ts.readConfigFile(config_filename, ts.sys.readFile);
 
 	if (error) {
 		throw new Error('Malformed tsconfig\n' + JSON.stringify(error, null, 2));
@@ -15532,54 +15523,215 @@ function load_tsconfig(filename, ts) {
 	const { options } = ts.parseJsonConfigFileContent(
 		config,
 		ts.sys,
-		path.dirname(tsconfig_filename),
+		path.dirname(config_filename),
 		{ sourceMap: false },
-		tsconfig_filename
+		config_filename
 	);
 	return options;
 }
 
+const essential_files = ['README', 'LICENSE', 'CHANGELOG', '.gitignore', '.npmignore'];
+
 /**
- * @param {string} file
- * @param {Parameters<typeof fs.writeFileSync>[1]} contents
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} cwd
  */
-function write(file, contents) {
-	mkdirp(path.dirname(file));
-	fs.writeFileSync(file, contents);
+async function build(config, cwd = process.cwd()) {
+	const { lib } = config.kit.files;
+	const { dir } = config.kit.package;
+
+	if (!fs.existsSync(lib)) {
+		throw new Error(`${lib} does not exist`);
+	}
+
+	rimraf(dir);
+	mkdirp(dir);
+
+	const files = scan(config);
+
+	if (config.kit.package.emitTypes) {
+		await emit_dts(config, cwd, files);
+	}
+
+	const pkg = generate_pkg(cwd, files);
+
+	if (!pkg.svelte && files.some((file) => file.is_svelte)) {
+		// Several heuristics in Kit/vite-plugin-svelte to tell Vite to mark Svelte packages
+		// rely on the "svelte" property. Vite/Rollup/Webpack plugin can all deal with it.
+		// See https://github.com/sveltejs/kit/issues/1959 for more info and related threads.
+		if (pkg.exports['.']) {
+			const svelte_export =
+				typeof pkg.exports['.'] === 'string'
+					? pkg.exports['.']
+					: pkg.exports['.'].import || pkg.exports['.'].default;
+			if (svelte_export) {
+				pkg.svelte = svelte_export;
+			} else {
+				console.warn(
+					'Cannot generate a "svelte" entry point because the "." entry in "exports" is not a string. If you set it by hand, please also set one of the options as a "svelte" entry point\n'
+				);
+			}
+		} else {
+			console.warn(
+				'Cannot generate a "svelte" entry point because the "." entry in "exports" is missing. Please specify one or set a "svelte" entry point yourself\n'
+			);
+		}
+	}
+
+	write(join(dir, 'package.json'), JSON.stringify(pkg, null, 2));
+
+	for (const file of files) {
+		await process_file(config, file);
+	}
+
+	const whitelist = fs.readdirSync(cwd).filter((file) => {
+		const lowercased = file.toLowerCase();
+		return essential_files.some((name) => lowercased.startsWith(name.toLowerCase()));
+	});
+
+	for (const pathname of whitelist) {
+		const full_path = join(cwd, pathname);
+		if (fs.lstatSync(full_path).isDirectory()) continue; // just to be sure
+
+		const package_path = join(dir, pathname);
+		if (!fs.existsSync(package_path)) fs.copyFileSync(full_path, package_path);
+	}
+
+	const from = relative(cwd, lib);
+	const to = relative(cwd, dir);
+	console.log($.bold().green(`${from} -> ${to}`));
+	console.log(`Successfully built '${pkg.name}' package. To publish it to npm:`);
+	console.log($.bold().cyan(`  cd ${to}`));
+	console.log($.bold().cyan('  npm publish\n'));
 }
 
 /**
  * @param {import('types').ValidatedConfig} config
  */
-async function emit_dts(config) {
-	const require = createRequire(import.meta.url);
-	const emit = await try_load_svelte2tsx();
-	await emit({
-		libRoot: config.kit.files.lib,
-		svelteShimsPath: require.resolve('svelte2tsx/svelte-shims.d.ts'),
-		declarationDir: config.kit.package.dir
+async function watch(config, cwd = process.cwd()) {
+	await build(config, cwd);
+
+	const message = `\nWatching ${relative(cwd, config.kit.files.lib)} for changes...\n`;
+
+	console.log(message);
+
+	const { lib } = config.kit.files;
+	const { dir } = config.kit.package;
+
+	/** @type {Array<{ file: import('./types').File, type: string }>} */
+	const pending = [];
+
+	/** @type {Array<(value?: any) => void>} */
+	const fulfillers = [];
+
+	/** @type {NodeJS.Timeout} */
+	let timeout;
+
+	const watcher = chokidar.watch(lib, { ignoreInitial: true });
+
+	watcher.on('all', async (type, path) => {
+		const file = analyze(config, relative(lib, path));
+		if (!file.is_included) return;
+
+		pending.push({ file, type });
+
+		clearTimeout(timeout);
+		timeout = setTimeout(async () => {
+			const files = scan(config);
+
+			let should_update_pkg = false;
+
+			const events = pending.slice();
+			pending.length = 0;
+
+			for (const { file, type } of events) {
+				if ((type === 'unlink' || type === 'add') && file.is_exported) {
+					should_update_pkg = true;
+				}
+
+				if (type === 'unlink') {
+					for (const candidate of [
+						file.name,
+						`${file.base}.d.ts`,
+						`${file.base}.d.mts`,
+						`${file.base}.d.cts`
+					]) {
+						const resolved = join(dir, candidate);
+
+						if (fs.existsSync(resolved)) {
+							fs.unlinkSync(resolved);
+
+							const parent = dirname(resolved);
+							if (parent !== dir && fs.readdirSync(parent).length === 0) {
+								fs.rmdirSync(parent);
+							}
+						}
+					}
+					console.log(`Removed ${file.dest}`);
+				}
+
+				if (type === 'add' || type === 'change') {
+					await process_file(config, file);
+					console.log(`Processing ${file.name}`);
+				}
+			}
+
+			if (should_update_pkg) {
+				const pkg = generate_pkg(cwd, files);
+				write(join(dir, 'package.json'), JSON.stringify(pkg, null, 2));
+				console.log('Updated package.json');
+			}
+
+			if (config.kit.package.emitTypes) {
+				await emit_dts(config, cwd, scan(config));
+				console.log('Updated .d.ts files');
+			}
+
+			console.log(message);
+
+			fulfillers.forEach((fn) => fn());
+		}, 100);
 	});
+
+	return {
+		watcher,
+		settled: () =>
+			new Promise((fulfil, reject) => {
+				fulfillers.push(fulfil);
+				setTimeout(() => reject(new Error('Timed out')), 1000);
+			})
+	};
 }
 
-async function try_load_svelte2tsx() {
-	const svelte2tsx = await load();
-	const emit_dts = svelte2tsx.emitDts;
-	if (!emit_dts) {
-		throw new Error(
-			'You need to install svelte2tsx >=0.4.1 if you want to generate type definitions'
-		);
-	}
-	return emit_dts;
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {import('./types').File} file
+ */
+async function process_file(config, file) {
+	if (!file.is_included) return;
 
-	async function load() {
-		try {
-			return await import('svelte2tsx');
-		} catch (e) {
-			throw new Error(
-				'You need svelte2tsx and typescript if you want to generate type definitions. Install it through your package manager, or disable generation which is highly discouraged. See https://kit.svelte.dev/docs/packaging'
-			);
+	const filename = join(config.kit.files.lib, file.name);
+	const dest = join(config.kit.package.dir, file.dest);
+
+	if (file.is_svelte || file.name.endsWith('.ts')) {
+		let contents = fs.readFileSync(filename, 'utf-8');
+
+		if (file.is_svelte) {
+			if (config.preprocess) {
+				const preprocessed = (await preprocess(contents, config.preprocess, { filename })).code;
+				contents = strip_lang_tags(preprocessed);
+			}
+		}
+
+		if (file.name.endsWith('.ts') && !file.name.endsWith('.d.ts')) {
+			contents = await transpile_ts(filename, contents);
 		}
+
+		contents = resolve_lib_alias(file.name, contents, config);
+		write(dest, contents);
+	} else {
+		copy(filename, dest);
 	}
 }
 
-export { emit_dts, make_package };
+export { build, watch };

package/dist/cli.js

@@ -870,7 +870,7 @@ async function launch(port, https, base) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}${base}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.316');
+const prog = sade('svelte-kit').version('1.0.0-next.319');
 
 prog
 	.command('dev')
@@ -981,13 +981,13 @@ prog
 prog
 	.command('package')
 	.describe('Create a package')
-	.action(async () => {
+	.option('-w, --watch', 'Rerun when files change', false)
+	.action(async ({ watch }) => {
 		try {
 			const config = await load_config();
+			const packaging = await import('./chunks/index6.js');
 
-			const { make_package } = await import('./chunks/index6.js');
-
-			await make_package(config);
+			await (watch ? packaging.watch(config) : packaging.build(config));
 		} catch (error) {
 			handle_error(error);
 		}
@@ -1049,7 +1049,7 @@ async function check_port(port) {
 function welcome({ port, host, https, open, base, loose, allow, cwd }) {
 	if (open) launch(port, https, base);
 
-	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.316'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.319'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.316",
+  "version": "1.0.0-next.319",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -11,6 +11,7 @@
   "type": "module",
   "dependencies": {
     "@sveltejs/vite-plugin-svelte": "^1.0.0-next.32",
+    "chokidar": "^3.5.3",
     "sade": "^1.7.4",
     "vite": "^2.9.0"
   },

package/types/index.d.ts

@@ -38,7 +38,7 @@ export interface Builder {
 	 * Create entry points that map to individual functions
 	 * @param fn A function that groups a set of routes into an entry point
 	 */
-	createEntries(fn: (route: RouteDefinition) => AdapterEntry): void;
+	createEntries(fn: (route: RouteDefinition) => AdapterEntry): Promise<void>;
 
 	generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
 

package/types/private.d.ts

@@ -23,7 +23,7 @@ export interface AdapterEntry {
 	 */
 	complete: (entry: {
 		generateManifest: (opts: { relativePath: string; format?: 'esm' | 'cjs' }) => string;
-	}) => void;
+	}) => MaybePromise<void>;
 }
 
 // Based on https://github.com/josh-hemphill/csp-typed-directives/blob/latest/src/csp.types.ts
@@ -222,6 +222,7 @@ export interface ResolveOptions {
 export type ResponseHeaders = Record<string, string | number | string[]>;
 
 export interface RouteDefinition {
+	id: string;
 	type: 'page' | 'endpoint';
 	pattern: RegExp;
 	segments: RouteSegment[];