@sveltejs/kit 1.0.0-next.291 → 1.0.0-next.292

package/dist/chunks/index5.js

@@ -2,10 +2,11 @@ import fs__default from 'fs';
 import http from 'http';
 import https from 'https';
 import { join } from 'path';
-import { s as sirv, S as SVELTE_KIT_ASSETS } from './constants.js';
+import { S as SVELTE_KIT_ASSETS, s as sirv } from './constants.js';
 import { pathToFileURL } from 'url';
 import { getRequest, setResponse } from '../node.js';
 import { installFetch } from '../install-fetch.js';
+import { n as normalize_path } from './url.js';
 import 'querystring';
 import 'stream';
 import 'node:http';
@@ -16,12 +17,21 @@ import 'node:util';
 import 'node:url';
 import 'net';
 
-/** @param {string} dir */
+/** @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) =>
-	sirv(dir, {
-		etag: true,
-		maxAge: 0
-	});
+	fs__default.existsSync(dir)
+		? sirv(dir, {
+				etag: true,
+				maxAge: 0
+		  })
+		: (req, res, next) => next();
 
 /**
  * @param {{
@@ -35,34 +45,21 @@ const mutable = (dir) =>
 async function preview({ port, host, config, https: use_https = false }) {
 	installFetch();
 
+	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);
 
-	/** @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(join(config.kit.outDir, 'output/client'), {
-		maxAge: 31536000,
-		immutable: true
-	});
-
-	const has_asset_path = !!config.kit.paths.assets;
-
 	override({
-		paths: {
-			base: config.kit.paths.base,
-			assets: has_asset_path ? SVELTE_KIT_ASSETS : config.kit.paths.base
-		},
+		paths: { base, assets },
 		prerendering: false,
 		protocol: use_https ? 'https' : 'http',
 		read: (file) => fs__default.readFileSync(join(config.kit.files.assets, file))
@@ -70,61 +67,103 @@ async function preview({ port, host, config, https: use_https = false }) {
 
 	const server = new Server(manifest);
 
-	/** @type {import('vite').UserConfig} */
-	const vite_config = (config.kit.vite && (await config.kit.vite())) || {};
+	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'), {
+				maxAge: 31536000,
+				immutable: true
+			})
+		),
+
+		// prerendered dependencies
+		scoped(base, mutable(join(config.kit.outDir, 'output/prerendered/dependencies'))),
+
+		// 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'];
+
+			if (if_none_match_value?.startsWith('W/"')) {
+				if_none_match_value = if_none_match_value.substring(2);
+			}
 
-	const http_server = await get_server(use_https, vite_config, (req, res) => {
-		if (req.url == null) {
-			throw new Error('Invalid request url');
-		}
+			if (if_none_match_value === etag) {
+				res.statusCode = 304;
+				res.end();
+				return;
+			}
 
-		const initial_url = req.url;
+			const { pathname, search } = new URL(/** @type {string} */ (req.url), 'http://dummy');
 
-		const render_handler = async () => {
-			if (initial_url.startsWith(config.kit.paths.base)) {
-				const protocol = use_https ? 'https' : 'http';
-				const host = req.headers['host'];
+			const normalized = normalize_path(pathname, config.kit.trailingSlash);
 
-				let request;
+			if (normalized !== pathname) {
+				res.writeHead(307, {
+					location: base + normalized + search
+				});
+				res.end();
+				return;
+			}
 
-				try {
-					req.url = initial_url;
-					request = await getRequest(`${protocol}://${host}`, req);
-				} catch (/** @type {any} */ err) {
-					res.statusCode = err.status || 400;
-					return res.end(err.reason || 'Invalid request body');
+			// 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')
+				);
+
+				if (fs__default.existsSync(file)) {
+					res.writeHead(200, {
+						'content-type': 'text/html',
+						etag
+					});
+
+					fs__default.createReadStream(file).pipe(res);
+					return;
 				}
-
-				setResponse(res, await server.respond(request));
-			} 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);
+
+			next();
+		}),
+
+		// SSR
+		async (req, res) => {
+			const protocol = use_https ? 'https' : 'http';
+			const host = req.headers['host'];
+
+			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');
 			}
-			assets_handler(req, res, () => {
-				static_handler(req, res, render_handler);
-			});
+
+			setResponse(res, await server.respond(request));
 		}
-	});
+	]);
 
-	await http_server.listen(port, host || '0.0.0.0');
+	const vite_config = (config.kit.vite && (await config.kit.vite())) || {};
 
-	return Promise.resolve(http_server);
+	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 || '0.0.0.0', () => {
+			fulfil(http_server);
+		});
+	});
 }
 
 /**
@@ -150,11 +189,54 @@ async function get_server(use_https, user_config, handler) {
 		}
 	}
 
-	return Promise.resolve(
-		use_https
-			? https.createServer(/** @type {https.ServerOptions} */ (https_options), handler)
-			: http.createServer(handler)
-	);
+	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');
+			}
+		}
+
+		next(0);
+	};
+}
+
+/**
+ * @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 { preview };

package/dist/chunks/index6.js

@@ -1,7 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createRequire } from 'module';
-import { f as rimraf, m as mkdirp, w as walk$1, $ } from '../cli.js';
+import { $ } from '../cli.js';
+import { r as rimraf, m as mkdirp, w as walk$1 } from './filesystem.js';
 import 'sade';
 import 'child_process';
 import 'net';

package/dist/chunks/object.js

@@ -0,0 +1,83 @@
+/**
+ * Takes zero or more objects and returns a new object that has all the values
+ * deeply merged together. None of the original objects will be mutated at any
+ * level, and the returned object will have no references to the original
+ * objects at any depth. If there's a conflict the last one wins, except for
+ * arrays which will be combined.
+ * @param {...Object} objects
+ * @returns {[Record<string, any>, string[]]} a 2-tuple with the merged object,
+ *     and a list of merge conflicts if there were any, in dotted notation
+ */
+function deep_merge(...objects) {
+	const result = {};
+	/** @type {string[]} */
+	const conflicts = [];
+	objects.forEach((o) => merge_into(result, o, conflicts));
+	return [result, conflicts];
+}
+
+/**
+ * normalize kit.vite.resolve.alias as an array
+ * @param {import('vite').AliasOptions} o
+ * @returns {import('vite').Alias[]}
+ */
+function normalize_alias(o) {
+	if (Array.isArray(o)) return o;
+	return Object.entries(o).map(([find, replacement]) => ({ find, replacement }));
+}
+
+/**
+ * Merges b into a, recursively, mutating a.
+ * @param {Record<string, any>} a
+ * @param {Record<string, any>} b
+ * @param {string[]} conflicts array to accumulate conflicts in
+ * @param {string[]} path array of property names representing the current
+ *     location in the tree
+ */
+function merge_into(a, b, conflicts = [], path = []) {
+	/**
+	 * Checks for "plain old Javascript object", typically made as an object
+	 * literal. Excludes Arrays and built-in types like Buffer.
+	 * @param {any} x
+	 */
+	const is_plain_object = (x) => typeof x === 'object' && x.constructor === Object;
+
+	for (const prop in b) {
+		// normalize alias objects to array
+		if (prop === 'alias' && path[path.length - 1] === 'resolve') {
+			if (a[prop]) a[prop] = normalize_alias(a[prop]);
+			if (b[prop]) b[prop] = normalize_alias(b[prop]);
+		}
+
+		if (is_plain_object(b[prop])) {
+			if (!is_plain_object(a[prop])) {
+				if (a[prop] !== undefined) {
+					conflicts.push([...path, prop].join('.'));
+				}
+				a[prop] = {};
+			}
+			merge_into(a[prop], b[prop], conflicts, [...path, prop]);
+		} else if (Array.isArray(b[prop])) {
+			if (!Array.isArray(a[prop])) {
+				if (a[prop] !== undefined) {
+					conflicts.push([...path, prop].join('.'));
+				}
+				a[prop] = [];
+			}
+			a[prop].push(...b[prop]);
+		} else {
+			// Since we're inside a for/in loop which loops over enumerable
+			// properties only, we want parity here and to check if 'a' has
+			// enumerable-only property 'prop'. Using 'hasOwnProperty' to
+			// exclude inherited properties is close enough. It is possible
+			// that someone uses Object.defineProperty to create a direct,
+			// non-enumerable property but let's not worry about that.
+			if (Object.prototype.hasOwnProperty.call(a, prop)) {
+				conflicts.push([...path, prop].join('.'));
+			}
+			a[prop] = b[prop];
+		}
+	}
+}
+
+export { deep_merge as d };