@sveltejs/kit 1.0.0-next.345 → 1.0.0-next.348

package/dist/chunks/index4.js

@@ -1,183 +1,267 @@
-import { $ } from '../cli.js';
-import { r as rimraf, m as mkdirp, c as copy } from './filesystem.js';
-import { g as generate_manifest } from './index3.js';
-import 'sade';
-import 'fs';
-import 'path';
-import 'child_process';
-import 'net';
+import fs__default from 'fs';
+import http from 'http';
+import https from 'https';
+import { join } from 'path';
+import { S as SVELTE_KIT_ASSETS, s as sirv } from './constants.js';
+import { pathToFileURL } from 'url';
+import { getRequest, setResponse } from '../node.js';
+import { installPolyfills } from '../node/polyfills.js';
+import { d as load_config } from '../cli.js';
+import 'querystring';
+import 'stream';
+import 'node:http';
+import 'node:https';
+import 'node:zlib';
+import 'node:stream';
+import 'node:buffer';
+import 'node:util';
+import 'node:url';
+import 'node:net';
+import 'node:fs';
+import 'node:path';
+import 'crypto';
 import 'chokidar';
-import 'url';
+import 'net';
+import 'child_process';
+import 'sade';
+import 'vite';
 import 'os';
-import './misc.js';
+
+/** @typedef {import('http').IncomingMessage} Req */
+/** @typedef {import('http').ServerResponse} Res */
+/** @typedef {(req: Req, res: Res, next: () => void) => void} Handler */
+
+/**
+ * @param {string} dir
+ * @returns {Handler}
+ */
+const mutable = (dir) =>
+	fs__default.existsSync(dir)
+		? sirv(dir, {
+				etag: true,
+				maxAge: 0
+		  })
+		: (req, res, next) => next();
 
 /**
  * @param {{
- *   config: import('types').ValidatedConfig;
- *   build_data: import('types').BuildData;
- *   prerendered: import('types').Prerendered;
- *   log: import('types').Logger;
+ *   port: number;
+ *   host?: string;
+ *   https?: boolean;
+ *   cwd?: string;
  * }} opts
- * @returns {import('types').Builder}
  */
-function create_builder({ config, build_data, prerendered, log }) {
-	/** @type {Set<string>} */
-	const prerendered_paths = new Set(prerendered.paths);
-
-	/** @param {import('types').RouteData} route */
-	// TODO routes should come pre-filtered
-	function not_prerendered(route) {
-		if (route.type === 'page' && route.path) {
-			return !prerendered_paths.has(route.path);
-		}
-
-		return true;
-	}
-
-	return {
-		log,
-		rimraf,
-		mkdirp,
-		copy,
-
-		config,
-		prerendered,
-
-		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('['),
-					rest: segment.includes('[...'),
-					content: segment
-				})),
-				pattern: route.pattern,
-				methods: route.type === 'page' ? ['get'] : build_data.server.methods[route.file]
-			}));
-
-			const seen = new Set();
-
-			for (let i = 0; i < routes.length; i += 1) {
-				const route = routes[i];
-				const { id, filter, complete } = fn(facades[i]);
-
-				if (seen.has(id)) continue;
-				seen.add(id);
-
-				const group = [route];
-
-				// figure out which lower priority routes should be considered fallbacks
-				for (let j = i + 1; j < routes.length; j += 1) {
-					if (filter(facades[j])) {
-						group.push(routes[j]);
+async function preview({ port, host, https: use_https = false }) {
+	installPolyfills();
+
+	const config = await load_config();
+	const { paths } = config.kit;
+	const base = paths.base;
+	const assets = paths.assets ? SVELTE_KIT_ASSETS : paths.base;
+
+	const etag = `"${Date.now()}"`;
+
+	const index_file = join(config.kit.outDir, 'output/server/index.js');
+	const manifest_file = join(config.kit.outDir, 'output/server/manifest.js');
+
+	/** @type {import('types').ServerModule} */
+	const { Server, override } = await import(pathToFileURL(index_file).href);
+	const { manifest } = await import(pathToFileURL(manifest_file).href);
+
+	override({
+		paths: { base, assets },
+		prerendering: false,
+		protocol: use_https ? 'https' : 'http',
+		read: (file) => fs__default.readFileSync(join(config.kit.files.assets, file))
+	});
+
+	const server = new Server(manifest);
+
+	const handle = compose([
+		// files in `static`
+		scoped(assets, mutable(config.kit.files.assets)),
+
+		// immutable generated client assets
+		scoped(
+			assets,
+			sirv(join(config.kit.outDir, 'output/client'), {
+				setHeaders: (res, pathname) => {
+					// only apply to build directory, not e.g. version.json
+					if (pathname.startsWith(`/${config.kit.appDir}/immutable`)) {
+						res.setHeader('cache-control', 'public,max-age=31536000,immutable');
 					}
 				}
-
-				const filtered = new Set(group.filter(not_prerendered));
-
-				// heuristic: if /foo/[bar] is included, /foo/[bar].json should
-				// also be included, since the page likely needs the endpoint
-				filtered.forEach((route) => {
-					if (route.type === 'page') {
-						const endpoint = routes.find((candidate) => candidate.id === route.id + '.json');
-
-						if (endpoint) {
-							filtered.add(endpoint);
-						}
-					}
-				});
-
-				if (filtered.size > 0) {
-					await complete({
-						generateManifest: ({ relativePath, format }) =>
-							generate_manifest({
-								build_data,
-								relative_path: relativePath,
-								routes: Array.from(filtered),
-								format
-							})
-					});
-				}
+			})
+		),
+
+		(req, res, next) => {
+			const original_url = /** @type {string} */ (req.url);
+			const { pathname } = new URL(original_url, 'http://dummy');
+
+			if (pathname.startsWith(base)) {
+				next();
+			} else {
+				res.statusCode = 404;
+				res.end(`Not found (did you mean ${base + pathname}?)`);
 			}
 		},
 
-		generateManifest: ({ relativePath, format }) => {
-			return generate_manifest({
-				build_data,
-				relative_path: relativePath,
-				routes: build_data.manifest_data.routes.filter(not_prerendered),
-				format
-			});
-		},
+		// prerendered dependencies
+		scoped(base, mutable(join(config.kit.outDir, 'output/prerendered/dependencies'))),
 
-		getBuildDirectory(name) {
-			return `${config.kit.outDir}/${name}`;
-		},
+		// prerendered pages (we can't just use sirv because we need to
+		// preserve the correct trailingSlash behaviour)
+		scoped(base, (req, res, next) => {
+			let if_none_match_value = req.headers['if-none-match'];
 
-		getClientDirectory() {
-			return `${config.kit.outDir}/output/client`;
-		},
+			if (if_none_match_value?.startsWith('W/"')) {
+				if_none_match_value = if_none_match_value.substring(2);
+			}
 
-		getServerDirectory() {
-			return `${config.kit.outDir}/output/server`;
-		},
+			if (if_none_match_value === etag) {
+				res.statusCode = 304;
+				res.end();
+				return;
+			}
 
-		getStaticDirectory() {
-			return config.kit.files.assets;
-		},
+			const { pathname } = new URL(/** @type {string} */ (req.url), 'http://dummy');
 
-		writeClient(dest) {
-			return copy(`${config.kit.outDir}/output/client`, dest);
-		},
+			// only treat this as a page if it doesn't include an extension
+			if (pathname === '/' || /\/[^./]+\/?$/.test(pathname)) {
+				const file = join(
+					config.kit.outDir,
+					'output/prerendered/pages' + pathname + (pathname.endsWith('/') ? 'index.html' : '.html')
+				);
 
-		writePrerendered(dest, { fallback } = {}) {
-			const source = `${config.kit.outDir}/output/prerendered`;
-			const files = [...copy(`${source}/pages`, dest), ...copy(`${source}/dependencies`, dest)];
+				if (fs__default.existsSync(file)) {
+					res.writeHead(200, {
+						'content-type': 'text/html',
+						etag
+					});
 
-			if (fallback) {
-				files.push(fallback);
-				copy(`${source}/fallback.html`, `${dest}/${fallback}`);
+					fs__default.createReadStream(file).pipe(res);
+					return;
+				}
 			}
 
-			return files;
-		},
+			next();
+		}),
 
-		writeServer(dest) {
-			return copy(`${config.kit.outDir}/output/server`, dest);
-		},
+		// SSR
+		async (req, res) => {
+			const protocol = use_https ? 'https' : 'http';
+			const host = req.headers['host'];
 
-		writeStatic(dest) {
-			return copy(config.kit.files.assets, dest);
-		},
+			let request;
+
+			try {
+				request = await getRequest(`${protocol}://${host}`, req);
+			} catch (/** @type {any} */ err) {
+				res.statusCode = err.status || 400;
+				return res.end(err.reason || 'Invalid request body');
+			}
 
-		// @ts-expect-error
-		async prerender() {
-			throw new Error(
-				'builder.prerender() has been removed. Prerendering now takes place in the build phase — see builder.prerender and builder.writePrerendered'
+			setResponse(
+				res,
+				await server.respond(request, {
+					getClientAddress: () => {
+						const { remoteAddress } = req.socket;
+						if (remoteAddress) return remoteAddress;
+						throw new Error('Could not determine clientAddress');
+					}
+				})
 			);
 		}
-	};
+	]);
+
+	const vite_config = (config.kit.vite && (await config.kit.vite())) || {};
+
+	const http_server = await get_server(use_https, vite_config, (req, res) => {
+		if (req.url == null) {
+			throw new Error('Invalid request url');
+		}
+
+		handle(req, res);
+	});
+
+	return new Promise((fulfil) => {
+		http_server.listen(port, host, () => {
+			fulfil({ server: http_server, config });
+		});
+	});
 }
 
 /**
- * @param {import('types').ValidatedConfig} config
- * @param {import('types').BuildData} build_data
- * @param {import('types').Prerendered} prerendered
- * @param {{ log: import('types').Logger }} 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, prerendered, { log }) {
-	const { name, adapt } = config.kit.adapter;
+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();
+		}
+	}
 
-	console.log($.bold().cyan(`\n> Using ${name}`));
+	return use_https
+		? https.createServer(/** @type {https.ServerOptions} */ (https_options), handler)
+		: http.createServer(handler);
+}
+
+/** @param {Handler[]} handlers */
+function compose(handlers) {
+	/**
+	 * @param {Req} req
+	 * @param {Res} res
+	 */
+	return (req, res) => {
+		/** @param {number} i */
+		function next(i) {
+			const handler = handlers[i];
+
+			if (handler) {
+				handler(req, res, () => next(i + 1));
+			} else {
+				res.statusCode = 404;
+				res.end('Not found');
+			}
+		}
 
-	const builder = create_builder({ config, build_data, prerendered, log });
-	await adapt(builder);
+		next(0);
+	};
+}
 
-	log.success('done');
+/**
+ * @param {string} scope
+ * @param {Handler} handler
+ * @returns {Handler}
+ */
+function scoped(scope, handler) {
+	if (scope === '') return handler;
+
+	return (req, res, next) => {
+		if (req.url?.startsWith(scope)) {
+			const original_url = req.url;
+			req.url = req.url.slice(scope.length);
+			handler(req, res, () => {
+				req.url = original_url;
+				next();
+			});
+		} else {
+			next();
+		}
+	};
 }
 
-export { adapt };
+export { preview };