@sveltejs/kit 1.0.0-next.206 → 1.0.0-next.208

package/dist/chunks/index4.js

@@ -1,490 +1,109 @@
-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 'node:http';
-import 'node:https';
-import 'node:zlib';
-import 'node:stream';
-import 'node:util';
-import 'node:url';
-
-/** @typedef {{
- *   fn: () => Promise<any>,
- *   fulfil: (value: any) => void,
- *   reject: (error: Error) => void
- * }} Task */
-
-/** @param {number} concurrency */
-function queue(concurrency) {
-	/** @type {Task[]} */
-	const tasks = [];
-
-	let current = 0;
-
-	/** @type {(value?: any) => void} */
-	let fulfil;
-
-	/** @type {(error: Error) => void} */
-	let reject;
-
-	let closed = false;
-
-	const done = new Promise((f, r) => {
-		fulfil = f;
-		reject = r;
-	});
-
-	done.catch(() => {
-		// this is necessary in case a catch handler is never added
-		// to the done promise by the user
-	});
-
-	function dequeue() {
-		if (current < concurrency) {
-			const task = tasks.shift();
-
-			if (task) {
-				current += 1;
-				const promise = Promise.resolve(task.fn());
-
-				promise
-					.then(task.fulfil, (err) => {
-						task.reject(err);
-						reject(err);
-					})
-					.then(() => {
-						current -= 1;
-						dequeue();
-					});
-			} else if (current === 0) {
-				closed = true;
-				fulfil();
-			}
-		}
-	}
-
-	return {
-		/** @param {() => any} fn */
-		add: (fn) => {
-			if (closed) throw new Error('Cannot add tasks to a queue that has ended');
-
-			const promise = new Promise((fulfil, reject) => {
-				tasks.push({ fn, fulfil, reject });
-			});
-
-			dequeue();
-			return promise;
-		},
-
-		done: () => {
-			if (current === 0) {
-				closed = true;
-				fulfil();
-			}
-
-			return done;
-		}
-	};
-}
+import { s } from './misc.js';
+import { g as get_mime_lookup } from '../cli.js';
 
 /**
- * @typedef {import('types/config').PrerenderErrorHandler} PrerenderErrorHandler
- * @typedef {import('types/config').PrerenderOnErrorValue} OnError
- * @typedef {import('types/internal').Logger} Logger
+ * @param {import('../../../types/internal').BuildData} build_data;
+ * @param {string} relative_path;
+ * @param {import('../../../types/internal').RouteData[]} routes;
+ * @param {'esm' | 'cjs'} format
  */
-
-/** @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))
+function generate_manifest(
+	build_data,
+	relative_path,
+	routes = build_data.manifest_data.routes,
+	format = 'esm'
+) {
+	const bundled_nodes = new Map();
+
+	// 0 and 1 are special, they correspond to the root layout and root error nodes
+	bundled_nodes.set(build_data.manifest_data.components[0], {
+		path: `${relative_path}/nodes/0.js`,
+		index: 0
 	});
 
-	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));
-		}
+	bundled_nodes.set(build_data.manifest_data.components[1], {
+		path: `${relative_path}/nodes/1.js`,
+		index: 1
 	});
 
-	/**
-	 * @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;
-	}
-
-	const q = queue(config.kit.prerender.concurrency);
-
-	/**
-	 * @param {string} decoded_path
-	 * @param {string?} referrer
-	 */
-	function enqueue(decoded_path, referrer) {
-		const path = encodeURI(normalize(decoded_path));
-
-		if (seen.has(path)) return;
-		seen.add(path);
-
-		return q.add(() => visit(path, decoded_path, referrer));
-	}
-
-	/**
-	 * @param {string} path
-	 * @param {string} decoded_path
-	 * @param {string?} referrer
-	 */
-	async function visit(path, decoded_path, referrer) {
-		/** @type {Map<string, import('types/hooks').ServerResponse>} */
-		const dependencies = new Map();
+	routes.forEach((route) => {
+		if (route.type === 'page') {
+			[...route.a, ...route.b].forEach((component) => {
+				if (component && !bundled_nodes.has(component)) {
+					const i = build_data.manifest_data.components.indexOf(component);
 
-		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)) {
-						enqueue(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'
+					bundled_nodes.set(component, {
+						path: `${relative_path}/nodes/${i}.js`,
+						index: bundled_nodes.size
 					});
 				}
 			});
+		}
+	});
 
-			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));
+	/** @type {(path: string) => string} */
+	const importer =
+		format === 'esm'
+			? (path) => `() => import('${path}')`
+			: (path) => `() => Promise.resolve().then(() => require('${path}'))`;
+
+	// prettier-ignore
+	return `{
+		appDir: ${s(build_data.app_dir)},
+		assets: new Set(${s(build_data.manifest_data.assets.map(asset => asset.file))}),
+		_: {
+			mime: ${s(get_mime_lookup(build_data.manifest_data))},
+			entry: ${s(build_data.client.entry)},
+			nodes: [
+				${Array.from(bundled_nodes.values()).map(node => importer(node.path)).join(',\n\t\t\t\t')}
+			],
+			routes: [
+				${routes.map(route => {
+					if (route.type === 'page') {
+						return `{
+							type: 'page',
+							pattern: ${route.pattern},
+							params: ${get_params(route.params)},
+							path: ${route.path ? s(route.path) : null},
+							a: ${s(route.a.map(component => component && bundled_nodes.get(component).index))},
+							b: ${s(route.b.map(component => component && bundled_nodes.get(component).index))}
+						}`.replace(/^\t\t/gm, '');
 					} else {
-						if (element === 'img') {
-							hrefs.push(get_src(attrs));
+						if (!build_data.server.vite_manifest[route.file]) {
+							// this is necessary in cases where a .css file snuck in —
+							// perhaps it would be better to disallow these (and others?)
+							return null;
 						}
-						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) ;
-
-					enqueue(pathname, path);
-				}
-			}
-		}
-	}
-
-	if (config.kit.prerender.enabled) {
-		for (const entry of config.kit.prerender.entries) {
-			if (entry === '*') {
-				for (const entry of build_data.entries) {
-					enqueue(entry, null);
-				}
-			} else {
-				enqueue(entry, null);
-			}
-		}
-
-		await q.done();
-	}
-
-	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
-			});
+						return `{
+							type: 'endpoint',
+							pattern: ${route.pattern},
+							params: ${get_params(route.params)},
+							load: ${importer(`${relative_path}/${build_data.server.vite_manifest[route.file].file}`)}
+						}`.replace(/^\t\t/gm, '');
+					}
+				}).filter(Boolean).join(',\n\t\t\t\t')}
+			]
 		}
-	};
+	}`.replace(/^\t/gm, '');
 }
 
-/**
- * @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');
+/** @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)}: m[${i + 1}] || ''`
+							: `${param}: m[${i + 1}]`;
+					})
+					.join(', ') +
+				'})'
+		: 'null';
 }
 
-export { adapt };
+export { generate_manifest as g };