@sveltejs/kit 1.0.0-next.344 → 1.0.0-next.347

package/dist/chunks/index3.js

@@ -1,118 +1,184 @@
-import { s, p as parse_route_id } from './misc.js';
-import { a as get_mime_lookup } from '../cli.js';
+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 'net';
+import 'child_process';
+import 'sade';
+import 'vite';
+import 'url';
+import 'os';
+import './misc.js';
 
 /**
  * @param {{
+ *   config: import('types').ValidatedConfig;
  *   build_data: import('types').BuildData;
- *   relative_path: string;
- *   routes: import('types').RouteData[];
- *   format?: 'esm' | 'cjs'
+ *   prerendered: import('types').Prerendered;
+ *   log: import('types').Logger;
  * }} opts
+ * @returns {import('types').Builder}
  */
-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
-					});
-				}
-			});
+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);
 		}
-	});
 
-	/** @type {(path: string) => string} */
-	const load =
-		format === 'esm'
-			? (path) => `import('${path}')`
-			: (path) => `Promise.resolve().then(() => require('${path}'))`;
+		return true;
+	}
 
-	/** @type {(path: string) => string} */
-	const loader = (path) => `() => ${load(path)}`;
+	return {
+		log,
+		rimraf,
+		mkdirp,
+		copy,
 
-	const assets = build_data.manifest_data.assets.map((asset) => asset.file);
-	if (build_data.service_worker) {
-		assets.push(build_data.service_worker);
-	}
+		config,
+		prerendered,
 
-	/** @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);
-					});
+		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') {
-						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;
-						}
+						const endpoint = routes.find((candidate) => candidate.id === route.id + '.json');
 
-						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, '');
+						if (endpoint) {
+							filtered.add(endpoint);
+						}
 					}
-				}).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(', ')} };
+				});
+
+				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'
+			);
 		}
-	}`.replace(/^\t/gm, '');
+	};
+}
+
+/**
+ * @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 { generate_manifest as g };
+export { adapt };