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

package/dist/chunks/index5.js

@@ -1,382 +1,407 @@
-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 { readFileSync, writeFileSync } from 'fs';
-import { resolve, join, dirname } from 'path';
-import { pathToFileURL, resolve as resolve$1, URL } from 'url';
+import * as fs from 'fs';
+import fs__default, { readdirSync, statSync } from 'fs';
+import http from 'http';
+import https from 'https';
+import { resolve, join, normalize } from 'path';
+import * as require$$7 from 'querystring';
+import { s as standard, M as Mime_1 } from './standard.js';
+import { pathToFileURL } from 'url';
+import { getRawBody } from '../node.js';
 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 'os';
-import './error.js';
-import 'http';
-import 'https';
+import { S as SVELTE_KIT, a as SVELTE_KIT_ASSETS } from './constants.js';
 import 'zlib';
 import 'stream';
 import 'util';
 import 'crypto';
 
 /**
- * @typedef {import('types/config').PrerenderErrorHandler} PrerenderErrorHandler
- * @typedef {import('types/config').PrerenderOnErrorValue} OnError
- * @typedef {import('types/internal').Logger} Logger
+ * @typedef ParsedURL
+ * @type {import('.').ParsedURL}
  */
 
-/** @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, '');
-}
+/**
+ * @typedef Request
+ * @property {string} url
+ * @property {ParsedURL} _parsedUrl
+ */
 
-/** @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 {Request} req
+ * @returns {ParsedURL|void}
+ */
+function parse(req) {
+	let raw = req.url;
+	if (raw == null) return;
 
-/** @param {string} attrs */
-function get_src(attrs) {
-	const match = /(?:[\s'"]|^)src\s*=\s*(?:"(.*?)"|'(.*?)'|([^\s>]*))/.exec(attrs);
-	return match && (match[1] || match[2] || match[3]);
-}
+	let prev = req._parsedUrl;
+	if (prev && prev.raw === raw) return prev;
 
-/** @param {string} attrs */
-function is_rel_external(attrs) {
-	const match = /rel\s*=\s*(?:["'][^>]*(external)[^>]*["']|(external))/.exec(attrs);
-	return !!match;
-}
+	let pathname=raw, search='', query;
+
+	if (raw.length > 1) {
+		let idx = raw.indexOf('?', 1);
 
-/** @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]);
+		if (idx !== -1) {
+			search = raw.substring(idx);
+			pathname = raw.substring(0, idx);
+			if (search.length > 1) {
+				query = require$$7.parse(search.substring(1));
+			}
 		}
 	}
-	return results;
-}
 
-/** @type {(errorDetails: Parameters<PrerenderErrorHandler>[0] ) => string} */
-function errorDetailsToString({ status, path, referrer, referenceType }) {
-	return `${status} ${path}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
+	return req._parsedUrl = { pathname, search, query, raw };
 }
 
-/** @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;
+function list(dir, callback, pre='') {
+	dir = resolve('.', dir);
+	let arr = readdirSync(dir);
+	let i=0, abs, stats;
+	for (; i < arr.length; i++) {
+		abs = join(dir, arr[i]);
+		stats = statSync(abs);
+		stats.isDirectory()
+			? list(abs, callback, join(pre, arr[i]))
+			: callback(join(pre, arr[i]), abs, stats);
 	}
 }
 
-const OK = 2;
-const REDIRECT = 3;
-
-/**
- * @param {{
- *   cwd: string;
- *   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 prerender({ cwd, out, log, config, build_data, fallback, all }) {
-	if (!config.kit.prerender.enabled && !fallback) {
-		return;
-	}
+let Mime = Mime_1;
+var lite = new Mime(standard);
 
-	__fetch_polyfill();
-
-	const dir = resolve(cwd, `${SVELTE_KIT}/output`);
-
-	const seen = new Set();
+const noop = () => {};
 
-	const server_root = resolve(dir);
-
-	/** @type {import('types/app').App} */
-	const app = await import(pathToFileURL(`${server_root}/server/app.js`).href);
+function isMatch(uri, arr) {
+	for (let i=0; i < arr.length; i++) {
+		if (arr[i].test(uri)) return true;
+	}
+}
 
-	app.init({
-		paths: config.kit.paths,
-		prerendering: true,
-		read: (file) => readFileSync(join(config.kit.files.assets, file))
-	});
+function toAssume(uri, extns) {
+	let i=0, x, len=uri.length - 1;
+	if (uri.charCodeAt(len) === 47) {
+		uri = uri.substring(0, len);
+	}
 
-	const error = chooseErrorHandler(log, config.kit.prerender.onError);
+	let arr=[], tmp=`${uri}/index`;
+	for (; i < extns.length; i++) {
+		x = extns[i] ? `.${extns[i]}` : '';
+		if (uri) arr.push(uri + x);
+		arr.push(tmp + x);
+	}
 
-	const files = new Set([...build_data.static, ...build_data.client]);
+	return arr;
+}
 
-	build_data.static.forEach((file) => {
-		if (file.endsWith('/index.html')) {
-			files.add(file.slice(0, -11));
-		}
-	});
+function viaCache(cache, uri, extns) {
+	let i=0, data, arr=toAssume(uri, extns);
+	for (; i < arr.length; i++) {
+		if (data = cache[arr[i]]) return data;
+	}
+}
 
-	/**
-	 * @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);
+function viaLocal(dir, isEtag, uri, extns) {
+	let i=0, arr=toAssume(uri, extns);
+	let abs, stats, name, headers;
+	for (; i < arr.length; i++) {
+		abs = normalize(join(dir, name=arr[i]));
+		if (abs.startsWith(dir) && fs.existsSync(abs)) {
+			stats = fs.statSync(abs);
+			if (stats.isDirectory()) continue;
+			headers = toHeaders(name, stats, isEtag);
+			headers['Cache-Control'] = isEtag ? 'no-cache' : 'no-store';
+			return { abs, stats, headers };
 		}
-
-		return path;
 	}
+}
 
-	/**
-	 * @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
-				}
-			}
-		);
-
-		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';
+function is404(req, res) {
+	return (res.statusCode=404,res.end());
+}
 
-			const parts = decoded_path.split('/');
-			if (is_html && parts[parts.length - 1] !== 'index.html') {
-				parts.push('index.html');
-			}
+function send(req, res, file, stats, headers) {
+	let code=200, tmp, opts={};
+	headers = { ...headers };
 
-			const file = `${out}${parts.join('/')}`;
-			mkdirp(dirname(file));
+	for (let key in headers) {
+		tmp = res.getHeader(key);
+		if (tmp) headers[key] = tmp;
+	}
 
-			if (response_type === REDIRECT) {
-				const location = get_single_valued_header(headers, 'location');
+	if (tmp = res.getHeader('content-type')) {
+		headers['Content-Type'] = tmp;
+	}
 
-				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}`);
-				}
+	if (req.headers.range) {
+		code = 206;
+		let [x, y] = req.headers.range.replace('bytes=', '').split('-');
+		let end = opts.end = parseInt(y, 10) || stats.size - 1;
+		let start = opts.start = parseInt(x, 10) || 0;
 
-				return;
-			}
+		if (start >= stats.size || end >= stats.size) {
+			res.setHeader('Content-Range', `bytes */${stats.size}`);
+			res.statusCode = 416;
+			return res.end();
+		}
 
-			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' });
-			}
+		headers['Content-Range'] = `bytes ${start}-${end}/${stats.size}`;
+		headers['Content-Length'] = (end - start + 1);
+		headers['Accept-Ranges'] = 'bytes';
+	}
 
-			dependencies.forEach((result, dependency_path) => {
-				const response_type = Math.floor(result.status / 100);
+	res.writeHead(code, headers);
+	fs.createReadStream(file, opts).pipe(res);
+}
 
-				const is_html = result.headers['content-type'] === 'text/html';
+function isEncoding(name, type, headers) {
+	headers['Content-Encoding'] = type;
+	headers['Content-Type'] = lite.getType(name.replace(/\.([^.]*)$/, '')) || '';
+}
 
-				const parts = dependency_path.split('/');
-				if (is_html && parts[parts.length - 1] !== 'index.html') {
-					parts.push('index.html');
-				}
+function toHeaders(name, stats, isEtag) {
+	let headers = {
+		'Content-Length': stats.size,
+		'Content-Type': lite.getType(name) || '',
+		'Last-Modified': stats.mtime.toUTCString(),
+	};
+	if (isEtag) headers['ETag'] = `W/"${stats.size}-${stats.mtime.getTime()}"`;
+	if (/\.br$/.test(name)) isEncoding(name, 'br', headers);
+	if (/\.gz$/.test(name)) isEncoding(name, 'gzip', headers);
+	return headers;
+}
 
-				const file = `${out}${parts.join('/')}`;
-				mkdirp(dirname(file));
+function sirv (dir, opts={}) {
+	dir = resolve(dir || '.');
 
-				if (result.body) writeFileSync(file, result.body);
+	let isNotFound = opts.onNoMatch || is404;
+	let setHeaders = opts.setHeaders || noop;
 
-				if (response_type === OK) {
-					log.info(`${result.status} ${dependency_path}`);
-				} else {
-					error({
-						status: result.status,
-						path: dependency_path,
-						referrer: path,
-						referenceType: 'fetched'
-					});
-				}
-			});
+	let extensions = opts.extensions || ['html', 'htm'];
+	let gzips = opts.gzip && extensions.map(x => `${x}.gz`).concat('gz');
+	let brots = opts.brotli && extensions.map(x => `${x}.br`).concat('br');
 
-			if (is_html && config.kit.prerender.crawl) {
-				const cleaned = clean_html(/** @type {string} */ (rendered.body));
+	const FILES = {};
 
-				let match;
-				const pattern = /<(a|img|link|source)\s+([\s\S]+?)>/gm;
+	let fallback = '/';
+	let isEtag = !!opts.etag;
+	let isSPA = !!opts.single;
+	if (typeof opts.single === 'string') {
+		let idx = opts.single.lastIndexOf('.');
+		fallback += !!~idx ? opts.single.substring(0, idx) : opts.single;
+	}
 
-				const hrefs = [];
+	let ignores = [];
+	if (opts.ignores !== false) {
+		ignores.push(/[/]([A-Za-z\s\d~$._-]+\.\w+){1,}$/); // any extn
+		if (opts.dotfiles) ignores.push(/\/\.\w/);
+		else ignores.push(/\/\.well-known/);
+		[].concat(opts.ignores || []).forEach(x => {
+			ignores.push(new RegExp(x, 'i'));
+		});
+	}
 
-				while ((match = pattern.exec(cleaned))) {
-					const element = match[1];
-					const attrs = match[2];
+	let cc = opts.maxAge != null && `public,max-age=${opts.maxAge}`;
+	if (cc && opts.immutable) cc += ',immutable';
+	else if (cc && opts.maxAge === 0) cc += ',must-revalidate';
 
-					if (element === 'a' || element === 'link') {
-						if (is_rel_external(attrs)) continue;
+	if (!opts.dev) {
+		list(dir, (name, abs, stats) => {
+			if (/\.well-known[\\+\/]/.test(name)) ; // keep
+			else if (!opts.dotfiles && /(^\.|[\\+|\/+]\.)/.test(name)) return;
 
-						hrefs.push(get_href(attrs));
-					} else {
-						if (element === 'img') {
-							hrefs.push(get_src(attrs));
-						}
-						hrefs.push(...get_srcset_urls(attrs));
-					}
-				}
+			let headers = toHeaders(name, stats, isEtag);
+			if (cc) headers['Cache-Control'] = cc;
 
-				for (const href of hrefs) {
-					if (!href) continue;
+			FILES['/' + name.normalize().replace(/\\+/g, '/')] = { abs, stats, headers };
+		});
+	}
 
-					const resolved = resolve$1(path, href);
-					if (!resolved.startsWith('/') || resolved.startsWith('//')) continue;
+	let lookup = opts.dev ? viaLocal.bind(0, dir, isEtag) : viaCache.bind(0, FILES);
 
-					const parsed = new URL(resolved, 'http://localhost');
-					const pathname = decodeURI(parsed.pathname);
+	return function (req, res, next) {
+		let extns = [''];
+		let pathname = parse(req).pathname;
+		let val = req.headers['accept-encoding'] || '';
+		if (gzips && val.includes('gzip')) extns.unshift(...gzips);
+		if (brots && /(br|brotli)/i.test(val)) extns.unshift(...brots);
+		extns.push(...extensions); // [...br, ...gz, orig, ...exts]
 
-					const file = pathname.replace(config.kit.paths.assets, '').slice(1);
-					if (files.has(file)) continue;
+		if (pathname.indexOf('%') !== -1) {
+			try { pathname = decodeURIComponent(pathname); }
+			catch (err) { /* malform uri */ }
+		}
 
-					if (parsed.search) ;
+		let data = lookup(pathname, extns) || isSPA && !isMatch(pathname, ignores) && lookup(fallback, extns);
+		if (!data) return next ? next() : isNotFound(req, res);
 
-					await visit(pathname.replace(config.kit.paths.base, ''), path);
-				}
-			}
+		if (isEtag && req.headers['if-none-match'] === data.headers['ETag']) {
+			res.writeHead(304);
+			return res.end();
 		}
-	}
 
-	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);
-				}
-			} else {
-				await visit(entry, null);
-			}
+		if (gzips || brots) {
+			res.setHeader('Vary', 'Accept-Encoding');
 		}
-	}
 
-	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
-				}
-			}
-		);
-
-		const file = join(out, fallback);
-		mkdirp(dirname(file));
-		writeFileSync(file, rendered.body || '');
-	}
+		setHeaders(res, pathname, data.stats);
+		send(req, res, data.abs, data.stats, data.headers);
+	};
 }
 
+/** @param {string} dir */
+const mutable = (dir) =>
+	sirv(dir, {
+		etag: true,
+		maxAge: 0
+	});
+
 /**
  * @param {{
- *   cwd: string;
+ *   port: number;
+ *   host?: string;
  *   config: import('types/config').ValidatedConfig;
- *   build_data: import('types/internal').BuildData;
- *   log: import('types/internal').Logger;
+ *   https?: boolean;
+ *   cwd?: string;
  * }} opts
- * @returns {import('types/config').AdapterUtils}
  */
-function get_utils({ cwd, config, build_data, log }) {
-	return {
-		log,
-		rimraf,
-		mkdirp,
-		copy,
-
-		copy_client_files(dest) {
-			copy(`${cwd}/${SVELTE_KIT}/output/client`, dest, (file) => file[0] !== '.');
-		},
+async function preview({
+	port,
+	host,
+	config,
+	https: use_https = false,
+	cwd = process.cwd()
+}) {
+	__fetch_polyfill();
 
-		copy_server_files(dest) {
-			copy(`${cwd}/${SVELTE_KIT}/output/server`, dest, (file) => file[0] !== '.');
-		},
+	const app_file = resolve(cwd, `${SVELTE_KIT}/output/server/app.js`);
+
+	/** @type {import('types/app').App} */
+	const app = await import(pathToFileURL(app_file).href);
+
+	/** @type {import('sirv').RequestHandler} */
+	const static_handler = fs__default.existsSync(config.kit.files.assets)
+		? mutable(config.kit.files.assets)
+		: (_req, _res, next) => {
+				if (!next) throw new Error('No next() handler is available');
+				return next();
+		  };
+
+	const assets_handler = sirv(resolve(cwd, `${SVELTE_KIT}/output/client`), {
+		maxAge: 31536000,
+		immutable: true
+	});
 
-		copy_static_files(dest) {
-			copy(config.kit.files.assets, dest);
+	const has_asset_path = !!config.kit.paths.assets;
+
+	app.init({
+		paths: {
+			base: config.kit.paths.base,
+			assets: has_asset_path ? SVELTE_KIT_ASSETS : config.kit.paths.base
 		},
+		prerendering: false,
+		read: (file) => fs__default.readFileSync(join(config.kit.files.assets, file))
+	});
+
+	/** @type {import('vite').UserConfig} */
+	const vite_config = (config.kit.vite && config.kit.vite()) || {};
+
+	const server = await get_server(use_https, vite_config, (req, res) => {
+		if (req.url == null) {
+			throw new Error('Invalid request url');
+		}
 
-		async prerender({ all = false, dest, fallback }) {
-			await prerender({
-				out: dest,
-				all,
-				cwd,
-				config,
-				build_data,
-				fallback,
-				log
+		const initial_url = req.url;
+
+		const render_handler = async () => {
+			if (!req.method) throw new Error('Incomplete request');
+
+			let body;
+
+			try {
+				body = await getRawBody(req);
+			} catch (/** @type {any} */ err) {
+				res.statusCode = err.status || 400;
+				return res.end(err.reason || 'Invalid request body');
+			}
+
+			const parsed = new URL(initial_url, 'http://localhost/');
+
+			const rendered =
+				parsed.pathname.startsWith(config.kit.paths.base) &&
+				(await app.render({
+					host: /** @type {string} */ (
+						config.kit.host || req.headers[config.kit.hostHeader || 'host']
+					),
+					method: req.method,
+					headers: /** @type {import('types/helper').RequestHeaders} */ (req.headers),
+					path: parsed.pathname.replace(config.kit.paths.base, ''),
+					query: parsed.searchParams,
+					rawBody: body
+				}));
+
+			if (rendered) {
+				res.writeHead(rendered.status, rendered.headers);
+				if (rendered.body) res.write(rendered.body);
+				res.end();
+			} else {
+				res.statusCode = 404;
+				res.end('Not found');
+			}
+		};
+
+		if (has_asset_path) {
+			if (initial_url.startsWith(SVELTE_KIT_ASSETS)) {
+				// custom assets path
+				req.url = initial_url.slice(SVELTE_KIT_ASSETS.length);
+				assets_handler(req, res, () => {
+					static_handler(req, res, render_handler);
+				});
+			} else {
+				render_handler();
+			}
+		} else {
+			if (initial_url.startsWith(config.kit.paths.base)) {
+				req.url = initial_url.slice(config.kit.paths.base.length);
+			}
+			assets_handler(req, res, () => {
+				static_handler(req, res, render_handler);
 			});
 		}
-	};
+	});
+
+	await server.listen(port, host || '0.0.0.0');
+
+	return Promise.resolve(server);
 }
 
 /**
- * @param {import('types/config').ValidatedConfig} config
- * @param {import('types/internal').BuildData} build_data
- * @param {{ cwd?: string, verbose: boolean }} opts
+ * @param {boolean} use_https
+ * @param {import('vite').UserConfig} user_config
+ * @param {(req: http.IncomingMessage, res: http.ServerResponse) => void} handler
+ * @returns {Promise<import('net').Server>}
  */
-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 });
+async function get_server(use_https, user_config, handler) {
+	/** @type {https.ServerOptions} */
+	const https_options = {};
+
+	if (use_https) {
+		const secure_opts = user_config.server
+			? /** @type {import('tls').SecureContextOptions} */ (user_config.server.https)
+			: {};
+
+		if (secure_opts.key && secure_opts.cert) {
+			https_options.key = secure_opts.key.toString();
+			https_options.cert = secure_opts.cert.toString();
+		} else {
+			https_options.key = https_options.cert = (await import('./cert.js')).createCertificate();
+		}
+	}
 
-	log.success('done');
+	return Promise.resolve(
+		use_https
+			? https.createServer(/** @type {https.ServerOptions} */ (https_options), handler)
+			: http.createServer(handler)
+	);
 }
 
-export { adapt };
+export { preview };