builder.js

import glob from 'tiny-glob';
import zlib from 'zlib';
import { existsSync, statSync, createReadStream, createWriteStream } from 'fs';
import { pipeline } from 'stream';
import { promisify } from 'util';
import { copy, rimraf, mkdirp } from '../../utils/filesystem.js';
import { generate_manifest } from '../generate_manifest/index.js';
import { get_path } from '../../utils/routing.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}
 */
export 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) {
		const path = route.page && get_path(route.id);
		if (path) {
			return !prerendered_paths.has(path) && !prerendered_paths.has(path + '/');
		}

		return true;
	}

	const pipe = promisify(pipeline);

	/**
	 * @param {string} file
	 * @param {'gz' | 'br'} format
	 */
	async function compress_file(file, format = 'gz') {
		const compress =
			format == 'br'
				? zlib.createBrotliCompress({
						params: {
							[zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
							[zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY,
							[zlib.constants.BROTLI_PARAM_SIZE_HINT]: statSync(file).size
						}
				  })
				: zlib.createGzip({ level: zlib.constants.Z_BEST_COMPRESSION });

		const source = createReadStream(file);
		const destination = createWriteStream(`${file}.${format}`);

		await pipe(source, compress, destination);
	}

	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) => {
				const methods = new Set();

				if (route.page) {
					methods.add('SET');
				}

				if (route.endpoint) {
					for (const method of build_data.server.methods[route.endpoint.file]) {
						methods.add(method);
					}
				}

				return {
					id: route.id,
					type: route.page ? 'page' : 'endpoint', // TODO change this if support pages+endpoints
					segments: route.id.split('/').map((segment) => ({
						dynamic: segment.includes('['),
						rest: segment.includes('[...'),
						content: segment
					})),
					pattern: route.pattern,
					methods: Array.from(methods)
				};
			});

			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
				// TODO is this still necessary, given the new way of doing things?
				filtered.forEach((route) => {
					if (route.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
			});
		},

		getBuildData() {
			return build_data;
		},

		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);
		},

		// TODO remove these methods for 1.0
		// @ts-expect-error
		writeStatic() {
			throw new Error(
				`writeStatic has been removed. Please ensure you are using the latest version of ${
					config.kit.adapter.name || 'your adapter'
				}`
			);
		},

		async compress(directory) {
			if (!existsSync(directory)) {
				return;
			}

			const files = await glob('**/*.{html,js,json,css,svg,xml,wasm}', {
				cwd: directory,
				dot: true,
				absolute: true,
				filesOnly: true
			});

			await Promise.all(
				files.map((file) => Promise.all([compress_file(file, 'gz'), compress_file(file, 'br')]))
			);
		},

		async prerender() {
			throw new Error(
				'builder.prerender() has been removed. Prerendering now takes place in the build phase — see builder.prerender and builder.writePrerendered'
			);
		}
	};
}