@sveltejs/kit 1.0.0-next.20 → 1.0.0-next.200

package/dist/chunks/index4.js

@@ -0,0 +1,398 @@
+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, URL } from 'url';
+import { __fetch_polyfill } from '../install-fetch.js';
+import { g as get_single_valued_header, r as resolve$1, i as is_root_relative } from './url.js';
+import 'sade';
+import 'child_process';
+import 'net';
+import 'os';
+import './error.js';
+import 'http';
+import 'https';
+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
+ */
+
+/** @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, '');
+}
+
+/** @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;
+}
+
+/** @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;
+}
+
+/** @type {(errorDetails: Parameters<PrerenderErrorHandler>[0] ) => string} */
+function errorDetailsToString({ status, path, referrer, referenceType }) {
+	return `${status} ${path}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
+}
+
+/** @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;
+ *   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
+ * @returns {Promise<Array<string>>} returns a promise that resolves to an array of paths corresponding to the files that have been prerendered.
+ */
+async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
+	if (!config.kit.prerender.enabled && !fallback) {
+		return [];
+	}
+
+	__fetch_polyfill();
+
+	const dir = resolve(cwd, `${SVELTE_KIT}/output`);
+
+	const seen = new Set();
+
+	const server_root = resolve(dir);
+
+	/** @type {import('types/internal').App} */
+	const app = await import(pathToFileURL(`${server_root}/server/app.js`).href);
+
+	app.init({
+		paths: config.kit.paths,
+		prerendering: true,
+		read: (file) => readFileSync(join(config.kit.files.assets, file))
+	});
+
+	const error = chooseErrorHandler(log, config.kit.prerender.onError);
+
+	const files = new Set([...build_data.static, ...build_data.client]);
+	const written_files = [];
+
+	build_data.static.forEach((file) => {
+		if (file.endsWith('/index.html')) {
+			files.add(file.slice(0, -11));
+		}
+	});
+
+	/**
+	 * @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);
+		}
+
+		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';
+
+			const parts = decoded_path.split('/');
+			if (is_html && parts[parts.length - 1] !== 'index.html') {
+				parts.push('index.html');
+			}
+
+			const file = `${out}${parts.join('/')}`;
+			mkdirp(dirname(file));
+
+			if (response_type === REDIRECT) {
+				const location = get_single_valued_header(headers, 'location');
+
+				if (location) {
+					log.warn(`${rendered.status} ${decoded_path} -> ${location}`);
+					writeFileSync(file, `<meta http-equiv="refresh" content="0;url=${encodeURI(location)}">`);
+					written_files.push(file);
+
+					const resolved = resolve$1(path, location);
+					if (is_root_relative(resolved)) {
+						await visit(resolved, path);
+					}
+				} else {
+					log.warn(`location header missing on redirect received from ${decoded_path}`);
+				}
+
+				return;
+			}
+
+			if (rendered.status === 200) {
+				log.info(`${rendered.status} ${decoded_path}`);
+				writeFileSync(file, rendered.body || '');
+				written_files.push(file);
+			} else if (response_type !== OK) {
+				error({ status: rendered.status, path, referrer, referenceType: 'linked' });
+			}
+
+			dependencies.forEach((result, dependency_path) => {
+				const response_type = Math.floor(result.status / 100);
+
+				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');
+				}
+
+				const file = `${out}${parts.join('/')}`;
+				mkdirp(dirname(file));
+
+				if (result.body) {
+					writeFileSync(file, result.body);
+					written_files.push(file);
+				}
+
+				if (response_type === OK) {
+					log.info(`${result.status} ${dependency_path}`);
+				} else {
+					error({
+						status: result.status,
+						path: dependency_path,
+						referrer: path,
+						referenceType: 'fetched'
+					});
+				}
+			});
+
+			if (is_html && config.kit.prerender.crawl) {
+				const cleaned = clean_html(/** @type {string} */ (rendered.body));
+
+				let match;
+				const pattern = /<(a|img|link|source)\s+([\s\S]+?)>/gm;
+
+				const hrefs = [];
+
+				while ((match = pattern.exec(cleaned))) {
+					const element = match[1];
+					const attrs = match[2];
+
+					if (element === 'a' || element === 'link') {
+						if (is_rel_external(attrs)) continue;
+
+						hrefs.push(get_href(attrs));
+					} else {
+						if (element === 'img') {
+							hrefs.push(get_src(attrs));
+						}
+						hrefs.push(...get_srcset_urls(attrs));
+					}
+				}
+
+				for (const href of hrefs) {
+					if (!href) continue;
+
+					const resolved = resolve$1(path, href);
+					if (!is_root_relative(resolved)) continue;
+
+					const parsed = new URL(resolved, 'http://localhost');
+					const pathname = decodeURI(parsed.pathname).replace(config.kit.paths.base, '');
+
+					const file = pathname.slice(1);
+					if (files.has(file)) continue;
+
+					if (parsed.search) ;
+
+					await visit(pathname, path);
+				}
+			}
+		}
+	}
+
+	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 (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,
+					dependencies: new Map()
+				}
+			}
+		);
+
+		const file = join(out, fallback);
+		mkdirp(dirname(file));
+		writeFileSync(file, rendered.body || '');
+		written_files.push(file);
+	}
+
+	return written_files;
+}
+
+/**
+ * @param {{
+ *   cwd: string;
+ *   config: import('types/config').ValidatedConfig;
+ *   build_data: import('types/internal').BuildData;
+ *   log: import('types/internal').Logger;
+ * }} opts
+ * @returns {import('types/config').AdapterUtils}
+ */
+function get_utils({ cwd, config, build_data, log }) {
+	return {
+		log,
+		rimraf,
+		mkdirp,
+		copy,
+
+		copy_client_files(dest) {
+			return copy(`${cwd}/${SVELTE_KIT}/output/client`, dest, (file) => file[0] !== '.');
+		},
+
+		copy_server_files(dest) {
+			return copy(`${cwd}/${SVELTE_KIT}/output/server`, dest, (file) => file[0] !== '.');
+		},
+
+		copy_static_files(dest) {
+			return copy(config.kit.files.assets, dest);
+		},
+
+		async prerender({ all = false, dest, fallback }) {
+			await prerender({
+				out: dest,
+				all,
+				cwd,
+				config,
+				build_data,
+				fallback,
+				log
+			});
+		}
+	};
+}
+
+/**
+ * @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 { adapt };