@sveltejs/kit 1.0.0-next.32 → 1.0.0-next.320

package/dist/chunks/index3.js

@@ -0,0 +1,118 @@
+import { s, p as parse_route_id } from './misc.js';
+import { a as get_mime_lookup } from '../cli.js';
+
+/**
+ * @param {{
+ *   build_data: import('types').BuildData;
+ *   relative_path: string;
+ *   routes: import('types').RouteData[];
+ *   format?: 'esm' | 'cjs'
+ * }} opts
+ */
+function generate_manifest({ build_data, relative_path, routes, format = 'esm' }) {
+	/** @typedef {{ index: number, path: string }} LookupEntry */
+	/** @type {Map<string, LookupEntry>} */
+	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
+	});
+
+	bundled_nodes.set(build_data.manifest_data.components[1], {
+		path: `${relative_path}/nodes/1.js`,
+		index: 1
+	});
+
+	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);
+
+					bundled_nodes.set(component, {
+						path: `${relative_path}/nodes/${i}.js`,
+						index: bundled_nodes.size
+					});
+				}
+			});
+		}
+	});
+
+	/** @type {(path: string) => string} */
+	const load =
+		format === 'esm'
+			? (path) => `import('${path}')`
+			: (path) => `Promise.resolve().then(() => require('${path}'))`;
+
+	/** @type {(path: string) => string} */
+	const loader = (path) => `() => ${load(path)}`;
+
+	const assets = build_data.manifest_data.assets.map((asset) => asset.file);
+	if (build_data.service_worker) {
+		assets.push(build_data.service_worker);
+	}
+
+	/** @param {string | undefined} id */
+	const get_index = (id) => id && /** @type {LookupEntry} */ (bundled_nodes.get(id)).index;
+
+	const matchers = new Set();
+
+	// prettier-ignore
+	return `{
+		appDir: ${s(build_data.app_dir)},
+		assets: new Set(${s(assets)}),
+		mimeTypes: ${s(get_mime_lookup(build_data.manifest_data))},
+		_: {
+			entry: ${s(build_data.client.entry)},
+			nodes: [
+				${Array.from(bundled_nodes.values()).map(node => loader(node.path)).join(',\n\t\t\t\t')}
+			],
+			routes: [
+				${routes.map(route => {
+					const { pattern, names, types } = parse_route_id(route.id);
+
+					types.forEach(type => {
+						if (type) matchers.add(type);
+					});
+
+					if (route.type === 'page') {
+						return `{
+							type: 'page',
+							id: ${s(route.id)},
+							pattern: ${pattern},
+							names: ${s(names)},
+							types: ${s(types)},
+							path: ${route.path ? s(route.path) : null},
+							shadow: ${route.shadow ? loader(`${relative_path}/${build_data.server.vite_manifest[route.shadow].file}`) : null},
+							a: ${s(route.a.map(get_index))},
+							b: ${s(route.b.map(get_index))}
+						}`.replace(/^\t\t/gm, '');
+					} else {
+						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;
+						}
+
+						return `{
+							type: 'endpoint',
+							id: ${s(route.id)},
+							pattern: ${pattern},
+							names: ${s(names)},
+							types: ${s(types)},
+							load: ${loader(`${relative_path}/${build_data.server.vite_manifest[route.file].file}`)}
+						}`.replace(/^\t\t/gm, '');
+					}
+				}).filter(Boolean).join(',\n\t\t\t\t')}
+			],
+			matchers: async () => {
+				${Array.from(matchers).map(type => `const { match: ${type} } = await ${load(`${relative_path}/entries/matchers/${type}.js`)}`).join('\n\t\t\t\t')}
+				return { ${Array.from(matchers).join(', ')} };
+			}
+		}
+	}`.replace(/^\t/gm, '');
+}
+
+export { generate_manifest as g };

package/dist/chunks/index4.js

@@ -0,0 +1,186 @@
+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 'url';
+import 'os';
+import './misc.js';
+
+/**
+ * @param {{
+ *   config: import('types').ValidatedConfig;
+ *   build_data: import('types').BuildData;
+ *   prerendered: import('types').Prerendered;
+ *   log: import('types').Logger;
+ * }} 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]);
+					}
+				}
+
+				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
+							})
+					});
+				}
+			}
+		},
+
+		generateManifest: ({ relativePath, format }) => {
+			return generate_manifest({
+				build_data,
+				relative_path: relativePath,
+				routes: build_data.manifest_data.routes.filter(not_prerendered),
+				format
+			});
+		},
+
+		getBuildDirectory(name) {
+			return `${config.kit.outDir}/${name}`;
+		},
+
+		getClientDirectory() {
+			return `${config.kit.outDir}/output/client`;
+		},
+
+		getServerDirectory() {
+			return `${config.kit.outDir}/output/server`;
+		},
+
+		getStaticDirectory() {
+			return config.kit.files.assets;
+		},
+
+		writeClient(dest) {
+			return copy(`${config.kit.outDir}/output/client`, dest, {
+				filter: (file) => file[0] !== '.'
+			});
+		},
+
+		writePrerendered(dest, { fallback } = {}) {
+			const source = `${config.kit.outDir}/output/prerendered`;
+			const files = [...copy(`${source}/pages`, dest), ...copy(`${source}/dependencies`, dest)];
+
+			if (fallback) {
+				files.push(fallback);
+				copy(`${source}/fallback.html`, `${dest}/${fallback}`);
+			}
+
+			return files;
+		},
+
+		writeServer(dest) {
+			return copy(`${config.kit.outDir}/output/server`, dest, {
+				filter: (file) => file[0] !== '.'
+			});
+		},
+
+		writeStatic(dest) {
+			return copy(config.kit.files.assets, dest);
+		},
+
+		// @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'
+			);
+		}
+	};
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {import('types').BuildData} build_data
+ * @param {import('types').Prerendered} prerendered
+ * @param {{ log: import('types').Logger }} opts
+ */
+async function adapt(config, build_data, prerendered, { log }) {
+	const { name, adapt } = config.kit.adapter;
+
+	console.log($.bold().cyan(`\n> Using ${name}`));
+
+	const builder = create_builder({ config, build_data, prerendered, log });
+	await adapt(builder);
+
+	log.success('done');
+}
+
+export { adapt };

package/dist/chunks/index5.js

@@ -0,0 +1,251 @@
+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 { installFetch } from '../install-fetch.js';
+import { n as normalize_path } from './url.js';
+import 'querystring';
+import 'stream';
+import 'node:http';
+import 'node:https';
+import 'node:zlib';
+import 'node:stream';
+import 'node:util';
+import 'node:url';
+import 'net';
+
+/** @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 {{
+ *   port: number;
+ *   host?: string;
+ *   config: import('types').ValidatedConfig;
+ *   https?: boolean;
+ *   cwd?: string;
+ * }} opts
+ */
+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);
+
+	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'), {
+				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);
+			}
+
+			if (if_none_match_value === etag) {
+				res.statusCode = 304;
+				res.end();
+				return;
+			}
+
+			const { pathname, search } = new URL(/** @type {string} */ (req.url), 'http://dummy');
+
+			const normalized = normalize_path(pathname, config.kit.trailingSlash);
+
+			if (normalized !== pathname) {
+				res.writeHead(307, {
+					location: base + normalized + search
+				});
+				res.end();
+				return;
+			}
+
+			// 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;
+				}
+			}
+
+			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');
+			}
+
+			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 || '0.0.0.0', () => {
+			fulfil(http_server);
+		});
+	});
+}
+
+/**
+ * @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 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();
+		}
+	}
+
+	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 };