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

package/dist/chunks/index2.js

@@ -1,120 +1,196 @@
-import { s, p as parse_route_id } from './misc.js';
-import { b as get_mime_lookup } from '../cli.js';
+import { $ } from './error.js';
+import { r as rimraf, m as mkdirp, c as copy } from './write_tsconfig.js';
+import { g as generate_manifest } from '../vite.js';
+import 'fs';
+import 'path';
+import 'url';
+import '@sveltejs/vite-plugin-svelte';
+import 'vite';
+import './sync.js';
+import '../node/polyfills.js';
+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 'querystring';
+import '../node.js';
+import 'stream';
 
 /**
- * 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.
+ * Creates the Builder which is passed to adapters for building the application.
  * @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 };

package/dist/chunks/sync.js

@@ -1,14 +1,8 @@
 import path__default from 'path';
 import fs__default from 'fs';
-import { a as get_runtime_path } from '../cli.js';
-import { p as posixify, c as copy, r as rimraf } from './filesystem.js';
-import { p as parse_route_id, s } from './misc.js';
+import { $ } from './error.js';
 import { fileURLToPath } from 'url';
-import { w as write_if_changed, t as trim, a as write, b as write_tsconfig } from './write_tsconfig.js';
-import 'chokidar';
-import 'sade';
-import 'vite';
-import 'os';
+import { p as posixify, c as copy, w as write_if_changed, t as trim, r as rimraf, a as write, b as write_tsconfig } from './write_tsconfig.js';
 
 /**
  * @param typeMap [Object] Map of MIME type -> Array[extensions]
@@ -113,6 +107,174 @@ var other = {"application/prs.cww":["cww"],"application/vnd.1000minds.decision-m
 let Mime = Mime_1;
 var mime = new Mime(standard, other);
 
+const get_runtime_path = /** @param {import('types').ValidatedKitConfig} config */ (config) =>
+			posixify_path(path__default.join(config.outDir, 'runtime'))
+	;
+
+/** @param {string} str */
+function posixify_path(str) {
+	const parsed = path__default.parse(str);
+	return `/${parsed.dir.slice(parsed.root.length).split(path__default.sep).join('/')}/${parsed.base}`;
+}
+
+function noop() {}
+
+/** @param {{ verbose: boolean }} opts */
+function logger({ verbose }) {
+	/** @type {import('types').Logger} */
+	const log = (msg) => console.log(msg.replace(/^/gm, '  '));
+
+	/** @param {string} msg */
+	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
+
+	log.success = (msg) => log($.green(`✔ ${msg}`));
+	log.error = (msg) => err($.bold().red(msg));
+	log.warn = (msg) => log($.bold().yellow(msg));
+
+	log.minor = verbose ? (msg) => log($.grey(msg)) : noop;
+	log.info = verbose ? log : noop;
+
+	return log;
+}
+
+/**
+ * Given an entry point like [cwd]/src/hooks, returns a filename like [cwd]/src/hooks.js or [cwd]/src/hooks/index.js
+ * @param {string} entry
+ * @returns {string|null}
+ */
+function resolve_entry(entry) {
+	if (fs__default.existsSync(entry)) {
+		const stats = fs__default.statSync(entry);
+		if (stats.isDirectory()) {
+			return resolve_entry(path__default.join(entry, 'index'));
+		}
+
+		return entry;
+	} else {
+		const dir = path__default.dirname(entry);
+
+		if (fs__default.existsSync(dir)) {
+			const base = path__default.basename(entry);
+			const files = fs__default.readdirSync(dir);
+
+			const found = files.find((file) => file.replace(/\.[^.]+$/, '') === base);
+
+			if (found) return path__default.join(dir, found);
+		}
+	}
+
+	return null;
+}
+
+/** @param {import('types').ManifestData} manifest_data */
+function get_mime_lookup(manifest_data) {
+	/** @type {Record<string, string>} */
+	const mime = {};
+
+	manifest_data.assets.forEach((asset) => {
+		if (asset.type) {
+			const ext = path__default.extname(asset.file);
+			mime[ext] = asset.type;
+		}
+	});
+
+	return mime;
+}
+
+/** @param {import('types').ValidatedKitConfig} config */
+function get_aliases(config) {
+	/** @type {Record<string, string>} */
+	const alias = {
+		__GENERATED__: path__default.posix.join(config.outDir, 'generated'),
+		$app: `${get_runtime_path(config)}/app`,
+
+		// For now, we handle `$lib` specially here rather than make it a default value for
+		// `config.kit.alias` since it has special meaning for packaging, etc.
+		$lib: config.files.lib
+	};
+
+	for (const [key, value] of Object.entries(config.alias)) {
+		alias[key] = path__default.resolve(value);
+	}
+
+	return alias;
+}
+
+const param_pattern = /^(\.\.\.)?(\w+)(?:=(\w+))?$/;
+
+/** @param {string} id */
+function parse_route_id(id) {
+	/** @type {string[]} */
+	const names = [];
+
+	/** @type {string[]} */
+	const types = [];
+
+	// `/foo` should get an optional trailing slash, `/foo.json` should not
+	// const add_trailing_slash = !/\.[a-z]+$/.test(key);
+	let add_trailing_slash = true;
+
+	const pattern =
+		id === ''
+			? /^\/$/
+			: new RegExp(
+					`^${decodeURIComponent(id)
+						.split(/(?:@[a-zA-Z0-9_-]+)?(?:\/|$)/)
+						.map((segment, i, segments) => {
+							// special case — /[...rest]/ could contain zero segments
+							const match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
+							if (match) {
+								names.push(match[1]);
+								types.push(match[2]);
+								return '(?:/(.*))?';
+							}
+
+							const is_last = i === segments.length - 1;
+
+							return (
+								segment &&
+								'/' +
+									segment
+										.split(/\[(.+?)\]/)
+										.map((content, i) => {
+											if (i % 2) {
+												const [, rest, name, type] = /** @type {RegExpMatchArray} */ (
+													param_pattern.exec(content)
+												);
+												names.push(name);
+												types.push(type);
+												return rest ? '(.*?)' : '([^/]+?)';
+											}
+
+											if (is_last && content.includes('.')) add_trailing_slash = false;
+
+											return (
+												content // allow users to specify characters on the file system in an encoded manner
+													.normalize()
+													// We use [ and ] to denote parameters, so users must encode these on the file
+													// system to match against them. We don't decode all characters since others
+													// can already be epressed and so that '%' can be easily used directly in filenames
+													.replace(/%5[Bb]/g, '[')
+													.replace(/%5[Dd]/g, ']')
+													// '#', '/', and '?' can only appear in URL path segments in an encoded manner.
+													// They will not be touched by decodeURI so need to be encoded here, so
+													// that we can match against them.
+													// We skip '/' since you can't create a file with it on any OS
+													.replace(/#/g, '%23')
+													.replace(/\?/g, '%3F')
+													// escape characters that have special meaning in regex
+													.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+											); // TODO handle encoding
+										})
+										.join('')
+							);
+						})
+						.join('')}${add_trailing_slash ? '/?' : ''}$`
+			  );
+
+	return { pattern, names, types };
+}
+
 /**
  * A portion of a file or directory name where the name has been split into
  * static and dynamic parts
@@ -586,6 +748,8 @@ function copy_assets(dest) {
 	} while (true); // eslint-disable-line
 }
 
+const s = JSON.stringify;
+
 /**
  * Writes the client manifest to disk. The manifest is used to power the router. It contains the
  * list of routes and corresponding Svelte components (i.e. pages and layouts).
@@ -853,4 +1017,11 @@ function all(config) {
 	return update(config);
 }
 
-export { all, init, update };
+var sync = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  init: init,
+  update: update,
+  all: all
+});
+
+export { get_runtime_path as a, get_mime_lookup as b, all as c, sync as d, get_aliases as g, init as i, logger as l, parse_route_id as p, resolve_entry as r, s, update as u };

package/dist/chunks/write_tsconfig.js

@@ -1,7 +1,112 @@
 import fs__default from 'fs';
 import path__default from 'path';
-import { $ } from '../cli.js';
-import { m as mkdirp, p as posixify } from './filesystem.js';
+import { $ } from './error.js';
+
+/** @param {string} dir */
+function mkdirp(dir) {
+	try {
+		fs__default.mkdirSync(dir, { recursive: true });
+	} catch (/** @type {any} */ e) {
+		if (e.code === 'EEXIST') return;
+		throw e;
+	}
+}
+
+/** @param {string} path */
+function rimraf(path) {
+	fs__default.rmSync(path, { force: true, recursive: true });
+}
+
+/**
+ * @param {string} source
+ * @param {string} target
+ * @param {{
+ *   filter?: (basename: string) => boolean;
+ *   replace?: Record<string, string>;
+ * }} opts
+ */
+function copy(source, target, opts = {}) {
+	if (!fs__default.existsSync(source)) return [];
+
+	/** @type {string[]} */
+	const files = [];
+
+	const prefix = posixify(target) + '/';
+
+	const regex = opts.replace
+		? new RegExp(`\\b(${Object.keys(opts.replace).join('|')})\\b`, 'g')
+		: null;
+
+	/**
+	 * @param {string} from
+	 * @param {string} to
+	 */
+	function go(from, to) {
+		if (opts.filter && !opts.filter(path__default.basename(from))) return;
+
+		const stats = fs__default.statSync(from);
+
+		if (stats.isDirectory()) {
+			fs__default.readdirSync(from).forEach((file) => {
+				go(path__default.join(from, file), path__default.join(to, file));
+			});
+		} else {
+			mkdirp(path__default.dirname(to));
+
+			if (opts.replace) {
+				const data = fs__default.readFileSync(from, 'utf-8');
+				fs__default.writeFileSync(
+					to,
+					data.replace(
+						/** @type {RegExp} */ (regex),
+						(match, key) => /** @type {Record<string, string>} */ (opts.replace)[key]
+					)
+				);
+			} else {
+				fs__default.copyFileSync(from, to);
+			}
+
+			files.push(to === target ? posixify(path__default.basename(to)) : posixify(to).replace(prefix, ''));
+		}
+	}
+
+	go(source, target);
+
+	return files;
+}
+
+/**
+ * Get a list of all files in a directory
+ * @param {string} cwd - the directory to walk
+ * @param {boolean} [dirs] - whether to include directories in the result
+ */
+function walk(cwd, dirs = false) {
+	/** @type {string[]} */
+	const all_files = [];
+
+	/** @param {string} dir */
+	function walk_dir(dir) {
+		const files = fs__default.readdirSync(path__default.join(cwd, dir));
+
+		for (const file of files) {
+			const joined = path__default.join(dir, file);
+			const stats = fs__default.statSync(path__default.join(cwd, joined));
+			if (stats.isDirectory()) {
+				if (dirs) all_files.push(joined);
+				walk_dir(joined);
+			} else {
+				all_files.push(joined);
+			}
+		}
+	}
+
+	return walk_dir(''), all_files;
+}
+
+/** @param {string} str */
+function posixify(str) {
+	return str.replace(/\\/g, '/');
+}
 
 /** @type {Map<string, string>} */
 const previous_contents = new Map();
@@ -166,4 +271,4 @@ function validate(config, cwd, out, user_file) {
 	}
 }
 
-export { write as a, write_tsconfig as b, trim as t, write_if_changed as w };
+export { write as a, write_tsconfig as b, copy as c, walk as d, mkdirp as m, posixify as p, rimraf as r, trim as t, write_if_changed as w };