@sveltejs/kit 1.0.0-next.35 → 1.0.0-next.350

package/dist/chunks/index2.js

@@ -0,0 +1,120 @@
+import { s, p as parse_route_id } from './misc.js';
+import { b as get_mime_lookup } from '../cli.js';
+
+/**
+ * Generates the data used to write the server-side manifest.js file. This data is used in the Vite
+ * build process, to power routing, etc.
+ * @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/index3.js

@@ -0,0 +1,183 @@
+import { $ } from '../cli.js';
+import { r as rimraf, m as mkdirp, c as copy } from './filesystem.js';
+import { g as generate_manifest } from './index2.js';
+import 'chokidar';
+import 'fs';
+import 'path';
+import 'sade';
+import 'vite';
+import 'url';
+import 'os';
+import './misc.js';
+
+/**
+ * Creates the Builder which is passed to adapters for building the application.
+ * @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);
+		},
+
+		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);
+		},
+
+		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/index4.js

@@ -0,0 +1,215 @@
+import fs__default from 'fs';
+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 'sade';
+import 'vite';
+import 'os';
+
+/** @typedef {import('http').IncomingMessage} Req */
+/** @typedef {import('http').ServerResponse} Res */
+/** @typedef {(req: Req, res: Res, next: () => void) => void} Handler */
+
+/** @type {import('types').ValidatedConfig} */
+let config;
+
+/** @type {boolean} */
+let https;
+
+/** @type {import('vite').Plugin} */
+const sveltekit_plugin = {
+	name: 'vite-plugin-svelte-kit',
+	async config(vite_config) {
+		// defaults
+		vite_config.preview = vite_config.preview || {};
+		vite_config.preview.strictPort = vite_config.preview.strictPort ?? true;
+
+		config = await load_config();
+	},
+	async configResolved(vite_config) {
+		https = !!vite_config.preview.https;
+	},
+	async configurePreviewServer(vite) {
+		installPolyfills();
+
+		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: https ? 'https' : 'http',
+			read: (file) => fs__default.readFileSync(join(config.kit.files.assets, file))
+		});
+
+		const server = new Server(manifest);
+
+		return () => {
+			// files in `static`
+			vite.middlewares.use(scoped(assets, mutable(config.kit.files.assets)));
+
+			// immutable generated client assets
+			vite.middlewares.use(
+				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');
+							}
+						}
+					})
+				)
+			);
+
+			vite.middlewares.use((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}?)`);
+				}
+			});
+
+			// prerendered dependencies
+			vite.middlewares.use(
+				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)
+			vite.middlewares.use(
+				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 } = new URL(/** @type {string} */ (req.url), 'http://dummy');
+
+					// 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
+			vite.middlewares.use(async (req, res) => {
+				const protocol = 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');
+						}
+					})
+				);
+			});
+		};
+	}
+};
+
+/**
+ * @param {string} dir
+ * @returns {Handler}
+ */
+const mutable = (dir) =>
+	fs__default.existsSync(dir)
+		? sirv(dir, {
+				etag: true,
+				maxAge: 0
+		  })
+		: (req, res, next) => next();
+
+/**
+ * @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 { sveltekit_plugin };