@sveltejs/kit 1.0.0-next.168 → 1.0.0-next.171

package/dist/chunks/index4.js

@@ -1,601 +1,382 @@
-import fs__default from 'fs';
-import path__default from 'path';
-import { svelte } from '@sveltejs/vite-plugin-svelte';
-import { c as create_manifest_data, g as glob, a as create_app, d as deep_merge } from './index2.js';
-import vite from 'vite';
-import { r as rimraf, a as resolve_entry, b as posixify, c as copy_assets, p as print_config_conflicts } from '../cli.js';
+import { m as mkdirp, r as rimraf, d as copy, $, l as logger } from '../cli.js';
 import { S as SVELTE_KIT } from './constants.js';
-import './standard.js';
-import 'os';
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve, join, dirname } from 'path';
+import { pathToFileURL, resolve as resolve$1, URL } from 'url';
+import { __fetch_polyfill } from '../install-fetch.js';
+import { g as get_single_valued_header } from './http.js';
 import 'sade';
 import 'child_process';
 import 'net';
-import 'url';
+import 'os';
 import './error.js';
-
-/** @param {any} value */
-const s = (value) => JSON.stringify(value);
-
-/** @typedef {Record<string, {
- *   file: string;
- *   css: string[];
- *   imports: string[];
- * }>} ClientManifest */
+import 'http';
+import 'https';
+import 'zlib';
+import 'stream';
+import 'util';
+import 'crypto';
 
 /**
- * @param {import('types/config').ValidatedConfig} config
- * @param {{
- *   cwd?: string;
- *   runtime?: string;
- * }} [opts]
- * @returns {Promise<import('types/internal').BuildData>}
+ * @typedef {import('types/config').PrerenderErrorHandler} PrerenderErrorHandler
+ * @typedef {import('types/config').PrerenderOnErrorValue} OnError
+ * @typedef {import('types/internal').Logger} Logger
  */
-async function build(config, { cwd = process.cwd(), runtime = '@sveltejs/kit/ssr' } = {}) {
-	const build_dir = path__default.resolve(cwd, `${SVELTE_KIT}/build`);
-
-	rimraf(build_dir);
-
-	const output_dir = path__default.resolve(cwd, `${SVELTE_KIT}/output`);
-
-	const options = {
-		cwd,
-		config,
-		build_dir,
-		// TODO this is so that Vite's preloading works. Unfortunately, it fails
-		// during `svelte-kit preview`, because we use a local asset path. If Vite
-		// used relative paths, I _think_ this could get fixed. Issue here:
-		// https://github.com/vitejs/vite/issues/2009
-		assets_base: `${config.kit.paths.assets || config.kit.paths.base}/${config.kit.appDir}/`,
-		manifest: create_manifest_data({
-			config,
-			output: build_dir,
-			cwd
-		}),
-		output_dir,
-		client_entry_file: `${SVELTE_KIT}/build/runtime/internal/start.js`,
-		service_worker_entry_file: resolve_entry(config.kit.files.serviceWorker)
-	};
 
-	const client_manifest = await build_client(options);
-	await build_server(options, client_manifest, runtime);
+/** @param {string} html */
+function clean_html(html) {
+	return html
+		.replace(/<!\[CDATA\[[\s\S]*?\]\]>/gm, '')
+		.replace(/(<script[\s\S]*?>)[\s\S]*?<\/script>/gm, '$1</' + 'script>')
+		.replace(/(<style[\s\S]*?>)[\s\S]*?<\/style>/gm, '$1</' + 'style>')
+		.replace(/<!--[\s\S]*?-->/gm, '');
+}
 
-	if (options.service_worker_entry_file) {
-		if (config.kit.paths.assets) {
-			throw new Error('Cannot use service worker alongside config.kit.paths.assets');
-		}
+/** @param {string} attrs */
+function get_href(attrs) {
+	const match = /(?:[\s'"]|^)href\s*=\s*(?:"(.*?)"|'(.*?)'|([^\s>]*))/.exec(attrs);
+	return match && (match[1] || match[2] || match[3]);
+}
+
+/** @param {string} attrs */
+function get_src(attrs) {
+	const match = /(?:[\s'"]|^)src\s*=\s*(?:"(.*?)"|'(.*?)'|([^\s>]*))/.exec(attrs);
+	return match && (match[1] || match[2] || match[3]);
+}
+
+/** @param {string} attrs */
+function is_rel_external(attrs) {
+	const match = /rel\s*=\s*(?:["'][^>]*(external)[^>]*["']|(external))/.exec(attrs);
+	return !!match;
+}
 
-		await build_service_worker(options, client_manifest);
+/** @param {string} attrs */
+function get_srcset_urls(attrs) {
+	const results = [];
+	// Note that the srcset allows any ASCII whitespace, including newlines.
+	const match = /([\s'"]|^)srcset\s*=\s*(?:"(.*?)"|'(.*?)'|([^\s>]*))/s.exec(attrs);
+	if (match) {
+		const attr_content = match[1] || match[2] || match[3];
+		// Parse the content of the srcset attribute.
+		// The regexp is modelled after the srcset specs (https://html.spec.whatwg.org/multipage/images.html#srcset-attribute)
+		// and should cover most reasonable cases.
+		const regex = /\s*([^\s,]\S+[^\s,])\s*((?:\d+w)|(?:-?\d+(?:\.\d+)?(?:[eE]-?\d+)?x))?/gm;
+		let sub_matches;
+		while ((sub_matches = regex.exec(attr_content))) {
+			results.push(sub_matches[1]);
+		}
 	}
+	return results;
+}
 
-	const client = glob('**', { cwd: `${output_dir}/client`, filesOnly: true }).map(posixify);
-	const server = glob('**', { cwd: `${output_dir}/server`, filesOnly: true }).map(posixify);
+/** @type {(errorDetails: Parameters<PrerenderErrorHandler>[0] ) => string} */
+function errorDetailsToString({ status, path, referrer, referenceType }) {
+	return `${status} ${path}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
+}
 
-	return {
-		client,
-		server,
-		static: options.manifest.assets.map((asset) => posixify(asset.file)),
-		entries: options.manifest.routes
-			.map((route) => (route.type === 'page' ? route.path : ''))
-			.filter(Boolean)
-	};
+/** @type {(log: Logger, onError: OnError) => PrerenderErrorHandler} */
+function chooseErrorHandler(log, onError) {
+	switch (onError) {
+		case 'continue':
+			return (errorDetails) => {
+				log.error(errorDetailsToString(errorDetails));
+			};
+		case 'fail':
+			return (errorDetails) => {
+				throw new Error(errorDetailsToString(errorDetails));
+			};
+		default:
+			return onError;
+	}
 }
 
+const OK = 2;
+const REDIRECT = 3;
+
 /**
  * @param {{
  *   cwd: string;
- *   assets_base: string;
- *   config: import('types/config').ValidatedConfig
- *   manifest: import('types/internal').ManifestData
- *   build_dir: string;
- *   output_dir: string;
- *   client_entry_file: string;
- *   service_worker_entry_file: string | null;
- * }} options
+ *   out: string;
+ *   log: Logger;
+ *   config: import('types/config').ValidatedConfig;
+ *   build_data: import('types/internal').BuildData;
+ *   fallback?: string;
+ *   all: boolean; // disregard `export const prerender = true`
+ * }} opts
  */
-async function build_client({
-	cwd,
-	assets_base,
-	config,
-	manifest,
-	build_dir,
-	output_dir,
-	client_entry_file
-}) {
-	create_app({
-		manifest_data: manifest,
-		output: build_dir,
-		cwd
-	});
+async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
+	if (!config.kit.prerender.enabled && !fallback) {
+		return;
+	}
 
-	copy_assets(build_dir);
+	__fetch_polyfill();
 
-	process.env.VITE_SVELTEKIT_AMP = config.kit.amp ? 'true' : '';
+	const dir = resolve(cwd, `${SVELTE_KIT}/output`);
 
-	const client_out_dir = `${output_dir}/client/${config.kit.appDir}`;
-	const client_manifest_file = `${client_out_dir}/manifest.json`;
+	const seen = new Set();
 
-	/** @type {Record<string, string>} */
-	const input = {
-		start: path__default.resolve(cwd, client_entry_file)
-	};
+	const server_root = resolve(dir);
+
+	/** @type {import('types/app').App} */
+	const app = await import(pathToFileURL(`${server_root}/server/app.js`).href);
 
-	// This step is optional — Vite/Rollup will create the necessary chunks
-	// for everything regardless — but it means that entry chunks reflect
-	// their location in the source code, which is helpful for debugging
-	manifest.components.forEach((file) => {
-		const resolved = path__default.resolve(cwd, file);
-		const relative = path__default.relative(config.kit.files.routes, resolved);
-
-		const name = relative.startsWith('..')
-			? path__default.basename(file)
-			: posixify(path__default.join('pages', relative));
-		input[name] = resolved;
+	app.init({
+		paths: config.kit.paths,
+		prerendering: true,
+		read: (file) => readFileSync(join(config.kit.files.assets, file))
 	});
 
-	/** @type {any} */
-	const vite_config = config.kit.vite();
+	const error = chooseErrorHandler(log, config.kit.prerender.onError);
 
-	const default_config = {
-		server: {
-			fs: {
-				strict: true
-			}
-		}
-	};
+	const files = new Set([...build_data.static, ...build_data.client]);
 
-	// don't warn on overriding defaults
-	const [modified_vite_config] = deep_merge(default_config, vite_config);
-
-	/** @type {[any, string[]]} */
-	const [merged_config, conflicts] = deep_merge(modified_vite_config, {
-		configFile: false,
-		root: cwd,
-		base: assets_base,
-		build: {
-			cssCodeSplit: true,
-			manifest: true,
-			outDir: client_out_dir,
-			polyfillDynamicImport: false,
-			rollupOptions: {
-				input,
-				output: {
-					entryFileNames: '[name]-[hash].js',
-					chunkFileNames: 'chunks/[name]-[hash].js',
-					assetFileNames: 'assets/[name]-[hash][extname]'
-				},
-				preserveEntrySignatures: 'strict'
-			}
-		},
-		resolve: {
-			alias: {
-				$app: path__default.resolve(`${build_dir}/runtime/app`),
-				$lib: config.kit.files.lib
-			}
-		},
-		plugins: [
-			svelte({
-				extensions: config.extensions,
-				emitCss: !config.kit.amp,
-				compilerOptions: {
-					hydratable: !!config.kit.hydrate
-				}
-			})
-		]
+	build_data.static.forEach((file) => {
+		if (file.endsWith('/index.html')) {
+			files.add(file.slice(0, -11));
+		}
 	});
 
-	print_config_conflicts(conflicts, 'kit.vite.', 'build_client');
+	/**
+	 * @param {string} path
+	 */
+	function normalize(path) {
+		if (config.kit.trailingSlash === 'always') {
+			return path.endsWith('/') ? path : `${path}/`;
+		} else if (config.kit.trailingSlash === 'never') {
+			return !path.endsWith('/') || path === '/' ? path : path.slice(0, -1);
+		}
 
-	await vite.build(merged_config);
+		return path;
+	}
 
-	/** @type {ClientManifest} */
-	const client_manifest = JSON.parse(fs__default.readFileSync(client_manifest_file, 'utf-8'));
-	fs__default.renameSync(client_manifest_file, `${output_dir}/manifest.json`); // inspectable but not shipped
+	/**
+	 * @param {string} decoded_path
+	 * @param {string?} referrer
+	 */
+	async function visit(decoded_path, referrer) {
+		const path = encodeURI(normalize(decoded_path));
+
+		if (seen.has(path)) return;
+		seen.add(path);
+
+		/** @type {Map<string, import('types/hooks').ServerResponse>} */
+		const dependencies = new Map();
+
+		const rendered = await app.render(
+			{
+				host: config.kit.host,
+				method: 'GET',
+				headers: {},
+				path,
+				rawBody: null,
+				query: new URLSearchParams()
+			},
+			{
+				prerender: {
+					all,
+					dependencies
+				}
+			}
+		);
 
-	return client_manifest;
-}
+		if (rendered) {
+			const response_type = Math.floor(rendered.status / 100);
+			const headers = rendered.headers;
+			const type = headers && headers['content-type'];
+			const is_html = response_type === REDIRECT || type === 'text/html';
 
-/**
- * @param {{
- *   cwd: string;
- *   assets_base: string;
- *   config: import('types/config').ValidatedConfig
- *   manifest: import('types/internal').ManifestData
- *   build_dir: string;
- *   output_dir: string;
- *   client_entry_file: string;
- *   service_worker_entry_file: string | null;
- * }} options
- * @param {ClientManifest} client_manifest
- * @param {string} runtime
- */
-async function build_server(
-	{
-		cwd,
-		assets_base,
-		config,
-		manifest,
-		build_dir,
-		output_dir,
-		client_entry_file,
-		service_worker_entry_file
-	},
-	client_manifest,
-	runtime
-) {
-	let hooks_file = resolve_entry(config.kit.files.hooks);
-	if (!hooks_file || !fs__default.existsSync(hooks_file)) {
-		hooks_file = path__default.resolve(cwd, `${SVELTE_KIT}/build/hooks.js`);
-		fs__default.writeFileSync(hooks_file, '');
-	}
+			const parts = decoded_path.split('/');
+			if (is_html && parts[parts.length - 1] !== 'index.html') {
+				parts.push('index.html');
+			}
 
-	const app_file = `${build_dir}/app.js`;
+			const file = `${out}${parts.join('/')}`;
+			mkdirp(dirname(file));
 
-	/** @type {(file: string) => string} */
-	const app_relative = (file) => {
-		const relative_file = path__default.relative(build_dir, path__default.resolve(cwd, file));
-		return relative_file[0] === '.' ? relative_file : `./${relative_file}`;
-	};
+			if (response_type === REDIRECT) {
+				const location = get_single_valued_header(headers, 'location');
 
-	const prefix = `/${config.kit.appDir}/`;
+				if (location) {
+					log.warn(`${rendered.status} ${decoded_path} -> ${location}`);
+					writeFileSync(file, `<meta http-equiv="refresh" content="0;url=${encodeURI(location)}">`);
+				} else {
+					log.warn(`location header missing on redirect received from ${decoded_path}`);
+				}
 
-	/**
-	 * @param {string} file
-	 * @param {Set<string>} js_deps
-	 * @param {Set<string>} css_deps
-	 */
-	function find_deps(file, js_deps, css_deps) {
-		const chunk = client_manifest[file];
+				return;
+			}
 
-		if (js_deps.has(chunk.file)) return;
-		js_deps.add(chunk.file);
+			if (rendered.status === 200) {
+				log.info(`${rendered.status} ${decoded_path}`);
+				writeFileSync(file, rendered.body || '');
+			} else if (response_type !== OK) {
+				error({ status: rendered.status, path, referrer, referenceType: 'linked' });
+			}
 
-		if (chunk.css) {
-			chunk.css.forEach((file) => css_deps.add(file));
-		}
+			dependencies.forEach((result, dependency_path) => {
+				const response_type = Math.floor(result.status / 100);
 
-		if (chunk.imports) {
-			chunk.imports.forEach((file) => find_deps(file, js_deps, css_deps));
-		}
-	}
+				const is_html = result.headers['content-type'] === 'text/html';
+
+				const parts = dependency_path.split('/');
+				if (is_html && parts[parts.length - 1] !== 'index.html') {
+					parts.push('index.html');
+				}
 
-	/** @type {Record<string, { entry: string, css: string[], js: string[], styles: string[] }>} */
-	const metadata_lookup = {};
+				const file = `${out}${parts.join('/')}`;
+				mkdirp(dirname(file));
 
-	manifest.components.forEach((file) => {
-		const js_deps = new Set();
-		const css_deps = new Set();
+				if (result.body) writeFileSync(file, result.body);
 
-		find_deps(file, js_deps, css_deps);
+				if (response_type === OK) {
+					log.info(`${result.status} ${dependency_path}`);
+				} else {
+					error({
+						status: result.status,
+						path: dependency_path,
+						referrer: path,
+						referenceType: 'fetched'
+					});
+				}
+			});
 
-		const js = Array.from(js_deps);
-		const css = Array.from(css_deps);
+			if (is_html && config.kit.prerender.crawl) {
+				const cleaned = clean_html(/** @type {string} */ (rendered.body));
 
-		const styles = config.kit.amp
-			? Array.from(css_deps).map((url) => {
-					const resolved = `${output_dir}/client/${config.kit.appDir}/${url}`;
-					return fs__default.readFileSync(resolved, 'utf-8');
-			  })
-			: [];
+				let match;
+				const pattern = /<(a|img|link|source)\s+([\s\S]+?)>/gm;
 
-		metadata_lookup[file] = {
-			entry: client_manifest[file].file,
-			css,
-			js,
-			styles
-		};
-	});
+				const hrefs = [];
 
-	/** @type {Set<string>} */
-	const entry_js = new Set();
-	/** @type {Set<string>} */
-	const entry_css = new Set();
-
-	find_deps(client_entry_file, entry_js, entry_css);
-
-	// prettier-ignore
-	fs__default.writeFileSync(
-		app_file,
-		`
-			import { respond } from '${runtime}';
-			import root from './generated/root.svelte';
-			import { set_paths, assets } from './runtime/paths.js';
-			import { set_prerendering } from './runtime/env.js';
-			import * as user_hooks from ${s(app_relative(hooks_file))};
-
-			const template = ({ head, body }) => ${s(fs__default.readFileSync(config.kit.files.template, 'utf-8'))
-				.replace('%svelte.head%', '" + head + "')
-				.replace('%svelte.body%', '" + body + "')};
-
-			let options = null;
-
-			const default_settings = { paths: ${s(config.kit.paths)} };
-
-			// allow paths to be overridden in svelte-kit preview
-			// and in prerendering
-			export function init(settings = default_settings) {
-				set_paths(settings.paths);
-				set_prerendering(settings.prerendering || false);
-
-				const hooks = get_hooks(user_hooks);
-
-				options = {
-					amp: ${config.kit.amp},
-					dev: false,
-					entry: {
-						file: assets + ${s(prefix + client_manifest[client_entry_file].file)},
-						css: [${Array.from(entry_css).map(dep => 'assets + ' + s(prefix + dep))}],
-						js: [${Array.from(entry_js).map(dep => 'assets + ' + s(prefix + dep))}]
-					},
-					fetched: undefined,
-					floc: ${config.kit.floc},
-					get_component_path: id => assets + ${s(prefix)} + entry_lookup[id],
-					get_stack: error => String(error), // for security
-					handle_error: (error, request) => {
-						hooks.handleError({ error, request });
-						error.stack = options.get_stack(error);
-					},
-					hooks,
-					hydrate: ${s(config.kit.hydrate)},
-					initiator: undefined,
-					load_component,
-					manifest,
-					paths: settings.paths,
-					prerender: ${config.kit.prerender.enabled},
-					read: settings.read,
-					root,
-					service_worker: ${service_worker_entry_file ? "'/service-worker.js'" : 'null'},
-					router: ${s(config.kit.router)},
-					ssr: ${s(config.kit.ssr)},
-					target: ${s(config.kit.target)},
-					template,
-					trailing_slash: ${s(config.kit.trailingSlash)}
-				};
-			}
+				while ((match = pattern.exec(cleaned))) {
+					const element = match[1];
+					const attrs = match[2];
 
-			const d = decodeURIComponent;
-			const empty = () => ({});
-
-			const manifest = {
-				assets: ${s(manifest.assets)},
-				layout: ${s(manifest.layout)},
-				error: ${s(manifest.error)},
-				routes: [
-					${manifest.routes
-				.map((route) => {
-					if (route.type === 'page') {
-						const params = get_params(route.params);
-
-						return `{
-									type: 'page',
-									pattern: ${route.pattern},
-									params: ${params},
-									a: [${route.a.map(file => file && s(file)).join(', ')}],
-									b: [${route.b.map(file => file && s(file)).join(', ')}]
-								}`;
+					if (element === 'a' || element === 'link') {
+						if (is_rel_external(attrs)) continue;
+
+						hrefs.push(get_href(attrs));
 					} else {
-						const params = get_params(route.params);
-						const load = `() => import(${s(app_relative(route.file))})`;
-
-						return `{
-									type: 'endpoint',
-									pattern: ${route.pattern},
-									params: ${params},
-									load: ${load}
-								}`;
+						if (element === 'img') {
+							hrefs.push(get_src(attrs));
+						}
+						hrefs.push(...get_srcset_urls(attrs));
 					}
-				})
-				.join(',\n\t\t\t\t\t')}
-				]
-			};
+				}
 
-			// this looks redundant, but the indirection allows us to access
-			// named imports without triggering Rollup's missing import detection
-			const get_hooks = hooks => ({
-				getSession: hooks.getSession || (() => ({})),
-				handle: hooks.handle || (({ request, resolve }) => resolve(request)),
-				handleError: hooks.handleError || (({ error }) => console.error(error.stack)),
-				externalFetch: hooks.externalFetch || fetch
-			});
+				for (const href of hrefs) {
+					if (!href) continue;
 
-			const module_lookup = {
-				${manifest.components.map(file => `${s(file)}: () => import(${s(app_relative(file))})`)}
-			};
+					const resolved = resolve$1(path, href);
+					if (!resolved.startsWith('/') || resolved.startsWith('//')) continue;
 
-			const metadata_lookup = ${s(metadata_lookup)};
-
-			async function load_component(file) {
-				const { entry, css, js, styles } = metadata_lookup[file];
-				return {
-					module: await module_lookup[file](),
-					entry: assets + ${s(prefix)} + entry,
-					css: css.map(dep => assets + ${s(prefix)} + dep),
-					js: js.map(dep => assets + ${s(prefix)} + dep),
-					styles
-				};
-			}
+					const parsed = new URL(resolved, 'http://localhost');
+					const pathname = decodeURI(parsed.pathname).replace(config.kit.paths.base, '');
 
-			export function render(request, {
-				prerender
-			} = {}) {
-				const host = ${config.kit.host ? s(config.kit.host) : `request.headers[${s(config.kit.hostHeader || 'host')}]`};
-				return respond({ ...request, host }, options, { prerender });
-			}
-		`
-			.replace(/^\t{3}/gm, '')
-			.trim()
-	);
-
-	/** @type {import('vite').UserConfig} */
-	const vite_config = config.kit.vite();
-
-	const default_config = {
-		server: {
-			fs: {
-				strict: true
+					const file = pathname.slice(1);
+					if (files.has(file)) continue;
+
+					if (parsed.search) ;
+
+					await visit(pathname, path);
+				}
 			}
 		}
-	};
+	}
 
-	// don't warn on overriding defaults
-	const [modified_vite_config] = deep_merge(default_config, vite_config);
-
-	/** @type {[any, string[]]} */
-	const [merged_config, conflicts] = deep_merge(modified_vite_config, {
-		configFile: false,
-		root: cwd,
-		base: assets_base,
-		build: {
-			target: 'es2018',
-			ssr: true,
-			outDir: `${output_dir}/server`,
-			polyfillDynamicImport: false,
-			rollupOptions: {
-				input: {
-					app: app_file
-				},
-				output: {
-					format: 'esm',
-					entryFileNames: '[name].js',
-					chunkFileNames: 'chunks/[name]-[hash].js',
-					assetFileNames: 'assets/[name]-[hash][extname]',
-					inlineDynamicImports: true
-				},
-				preserveEntrySignatures: 'strict'
-			}
-		},
-		plugins: [
-			svelte({
-				extensions: config.extensions,
-				compilerOptions: {
-					hydratable: !!config.kit.hydrate
+	if (config.kit.prerender.enabled) {
+		for (const entry of config.kit.prerender.entries) {
+			if (entry === '*') {
+				for (const entry of build_data.entries) {
+					await visit(entry, null);
 				}
-			})
-		],
-		resolve: {
-			alias: {
-				$app: path__default.resolve(`${build_dir}/runtime/app`),
-				$lib: config.kit.files.lib
+			} else {
+				await visit(entry, null);
 			}
 		}
-	});
+	}
 
-	print_config_conflicts(conflicts, 'kit.vite.', 'build_server');
+	if (fallback) {
+		const rendered = await app.render(
+			{
+				host: config.kit.host,
+				method: 'GET',
+				headers: {},
+				path: '[fallback]', // this doesn't matter, but it's easiest if it's a string
+				rawBody: null,
+				query: new URLSearchParams()
+			},
+			{
+				prerender: {
+					fallback,
+					all: false
+				}
+			}
+		);
 
-	await vite.build(merged_config);
+		const file = join(out, fallback);
+		mkdirp(dirname(file));
+		writeFileSync(file, rendered.body || '');
+	}
 }
 
 /**
  * @param {{
  *   cwd: string;
- *   assets_base: string;
- *   config: import('types/config').ValidatedConfig
- *   manifest: import('types/internal').ManifestData
- *   build_dir: string;
- *   output_dir: string;
- *   client_entry_file: string;
- *   service_worker_entry_file: string | null;
- * }} options
- * @param {ClientManifest} client_manifest
+ *   config: import('types/config').ValidatedConfig;
+ *   build_data: import('types/internal').BuildData;
+ *   log: import('types/internal').Logger;
+ * }} opts
+ * @returns {import('types/config').AdapterUtils}
  */
-async function build_service_worker(
-	{ cwd, assets_base, config, manifest, build_dir, output_dir, service_worker_entry_file },
-	client_manifest
-) {
-	// TODO add any assets referenced in template .html file, e.g. favicon?
-	const app_files = new Set();
-	for (const key in client_manifest) {
-		const { file, css } = client_manifest[key];
-		app_files.add(file);
-		if (css) {
-			css.forEach((file) => {
-				app_files.add(file);
-			});
-		}
-	}
+function get_utils({ cwd, config, build_data, log }) {
+	return {
+		log,
+		rimraf,
+		mkdirp,
+		copy,
 
-	fs__default.writeFileSync(
-		`${build_dir}/runtime/service-worker.js`,
-		`
-			export const timestamp = ${Date.now()};
-
-			export const build = [
-				${Array.from(app_files)
-					.map((file) => `${s(`${config.kit.paths.base}/${config.kit.appDir}/${file}`)}`)
-					.join(',\n\t\t\t\t')}
-			];
-
-			export const files = [
-				${manifest.assets
-					.map((asset) => `${s(`${config.kit.paths.base}/${asset.file}`)}`)
-					.join(',\n\t\t\t\t')}
-			];
-		`
-			.replace(/^\t{3}/gm, '')
-			.trim()
-	);
-
-	/** @type {any} */
-	const vite_config = config.kit.vite();
-
-	const default_config = {
-		server: {
-			fs: {
-				strict: true
-			}
-		}
-	};
+		copy_client_files(dest) {
+			copy(`${cwd}/${SVELTE_KIT}/output/client`, dest, (file) => file[0] !== '.');
+		},
 
-	// don't warn on overriding defaults
-	const [modified_vite_config] = deep_merge(default_config, vite_config);
-
-	/** @type {[any, string[]]} */
-	const [merged_config, conflicts] = deep_merge(modified_vite_config, {
-		configFile: false,
-		root: cwd,
-		base: assets_base,
-		build: {
-			lib: {
-				entry: service_worker_entry_file,
-				name: 'app',
-				formats: ['es']
-			},
-			rollupOptions: {
-				output: {
-					entryFileNames: 'service-worker.js'
-				}
-			},
-			outDir: `${output_dir}/client`,
-			emptyOutDir: false
+		copy_server_files(dest) {
+			copy(`${cwd}/${SVELTE_KIT}/output/server`, dest, (file) => file[0] !== '.');
 		},
-		resolve: {
-			alias: {
-				'$service-worker': path__default.resolve(`${build_dir}/runtime/service-worker`),
-				$lib: config.kit.files.lib
-			}
-		}
-	});
 
-	print_config_conflicts(conflicts, 'kit.vite.', 'build_service_worker');
+		copy_static_files(dest) {
+			copy(config.kit.files.assets, dest);
+		},
 
-	await vite.build(merged_config);
+		async prerender({ all = false, dest, fallback }) {
+			await prerender({
+				out: dest,
+				all,
+				cwd,
+				config,
+				build_data,
+				fallback,
+				log
+			});
+		}
+	};
 }
 
-/** @param {string[]} array */
-function get_params(array) {
-	// given an array of params like `['x', 'y', 'z']` for
-	// src/routes/[x]/[y]/[z]/svelte, create a function
-	// that turns a RexExpMatchArray into ({ x, y, z })
-	return array.length
-		? '(m) => ({ ' +
-				array
-					.map((param, i) => {
-						return param.startsWith('...')
-							? `${param.slice(3)}: d(m[${i + 1}] || '')`
-							: `${param}: d(m[${i + 1}])`;
-					})
-					.join(', ') +
-				'})'
-		: 'empty';
+/**
+ * @param {import('types/config').ValidatedConfig} config
+ * @param {import('types/internal').BuildData} build_data
+ * @param {{ cwd?: string, verbose: boolean }} opts
+ */
+async function adapt(config, build_data, { cwd = process.cwd(), verbose }) {
+	const { name, adapt } = config.kit.adapter;
+
+	console.log($.bold().cyan(`\n> Using ${name}`));
+
+	const log = logger({ verbose });
+	const utils = get_utils({ cwd, config, build_data, log });
+	await adapt({ utils, config });
+
+	log.success('done');
 }
 
-export { build };
+export { adapt };