@sveltejs/kit 1.0.0-next.430 → 1.0.0-next.433

package/src/core/sync/create_manifest_data/index.js

@@ -3,9 +3,7 @@ import path from 'path';
 import mime from 'mime';
 import { runtime_directory } from '../../utils.js';
 import { posixify } from '../../../utils/filesystem.js';
-import { parse_route_id } from '../../../utils/routing.js';
-
-const DEFAULT = 'default';
+import { parse_route_id, affects_path } from '../../../utils/routing.js';
 
 /**
  * @param {{
@@ -20,261 +18,296 @@ export default function create_manifest_data({
 	fallback = `${runtime_directory}/components`,
 	cwd = process.cwd()
 }) {
-	/** @type {Map<string, import('types').RouteData>} */
-	const route_map = new Map();
+	const assets = create_assets(config);
+	const matchers = create_matchers(config, cwd);
+	const { nodes, routes } = create_routes_and_nodes(cwd, config, fallback);
 
-	/** @type {Map<string, import('./types').Part[][]>} */
-	const segment_map = new Map();
+	return {
+		assets,
+		matchers,
+		nodes,
+		routes
+	};
+}
 
-	/** @type {import('./types').RouteTree} */
-	const tree = new Map();
+/**
+ * @param {import('types').ValidatedConfig} config
+ */
+function create_assets(config) {
+	return list_files(config.kit.files.assets).map((file) => ({
+		file,
+		size: fs.statSync(path.resolve(config.kit.files.assets, file)).size,
+		type: mime.getType(file)
+	}));
+}
 
-	const default_layout = {
-		component: posixify(path.relative(cwd, `${fallback}/layout.svelte`))
-	};
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} cwd
+ */
+function create_matchers(config, cwd) {
+	const params_base = path.relative(cwd, config.kit.files.params);
 
-	// set default root layout/error
-	tree.set('', {
-		error: {
-			component: posixify(path.relative(cwd, `${fallback}/error.svelte`))
-		},
-		layouts: { [DEFAULT]: default_layout }
-	});
-
-	/** @param {string} id */
-	function tree_node(id) {
-		if (!tree.has(id)) {
-			tree.set(id, {
-				error: undefined,
-				layouts: {}
-			});
-		}
+	/** @type {Record<string, string>} */
+	const matchers = {};
+	if (fs.existsSync(config.kit.files.params)) {
+		for (const file of fs.readdirSync(config.kit.files.params)) {
+			const ext = path.extname(file);
+			if (!config.kit.moduleExtensions.includes(ext)) continue;
+			const type = file.slice(0, -ext.length);
 
-		return /** @type {import('./types').RouteTreeNode} */ (tree.get(id));
-	}
+			if (/^\w+$/.test(type)) {
+				const matcher_file = path.join(params_base, file);
 
-	const routes_base = posixify(path.relative(cwd, config.kit.files.routes));
-	const valid_extensions = [...config.extensions, ...config.kit.moduleExtensions];
+				// Disallow same matcher with different extensions
+				if (matchers[type]) {
+					throw new Error(`Duplicate matchers: ${matcher_file} and ${matchers[type]}`);
+				} else {
+					matchers[type] = matcher_file;
+				}
+			} else {
+				throw new Error(
+					`Matcher names can only have underscores and alphanumeric characters — "${file}" is invalid`
+				);
+			}
+		}
+	}
 
-	if (fs.existsSync(config.kit.files.routes)) {
-		list_files(config.kit.files.routes).forEach((filepath) => {
-			const extension = valid_extensions.find((ext) => filepath.endsWith(ext));
-			if (!extension) return;
+	return matchers;
+}
 
-			const project_relative = `${routes_base}/${filepath}`;
-			const segments = filepath.split('/');
-			const file = /** @type {string} */ (segments.pop());
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} cwd
+ * @param {string} fallback
+ */
+function create_routes_and_nodes(cwd, config, fallback) {
+	const route_map = new Map();
 
-			if (file[0] !== '+') return; // not a route file
+	/** @type {Map<string, import('./types').Part[][]>} */
+	const segment_map = new Map();
 
-			const item = analyze(project_relative, file, config.extensions, config.kit.moduleExtensions);
-			const id = segments.join('/');
+	const routes_base = posixify(path.relative(cwd, config.kit.files.routes));
 
-			if (/\]\[/.test(id)) {
-				throw new Error(`Invalid route ${project_relative} — parameters must be separated`);
-			}
+	const valid_extensions = [...config.extensions, ...config.kit.moduleExtensions];
 
-			if (count_occurrences('[', id) !== count_occurrences(']', id)) {
-				throw new Error(`Invalid route ${project_relative} — brackets are unbalanced`);
-			}
+	/** @type {import('types').PageNode[]} */
+	const nodes = [];
 
-			// error/layout files should be added to the tree, but don't result
-			// in a route being created, so deal with them first. note: we are
-			// relying on the fact that the +error and +layout files precede
-			// +page files alphabetically, and will therefore be processes
-			// before we reach the page
-			if (item.kind === 'component' && item.is_error) {
-				tree_node(id).error = {
-					component: project_relative
-				};
-
-				return;
-			}
+	if (fs.existsSync(config.kit.files.routes)) {
+		/**
+		 * @param {number} depth
+		 * @param {string} id
+		 * @param {string} segment
+		 * @param {import('types').RouteData | null} parent
+		 */
+		const walk = (depth, id, segment, parent) => {
+			const { pattern, names, types } = parse_route_id(id);
+
+			const segments = id.split('/');
+
+			segment_map.set(
+				id,
+				segments.filter(Boolean).map((segment) => {
+					/** @type {import('./types').Part[]} */
+					const parts = [];
+					segment.split(/\[(.+?)\]/).map((content, i) => {
+						const dynamic = !!(i % 2);
+
+						if (!content) return;
+
+						parts.push({
+							content,
+							dynamic,
+							rest: dynamic && content.startsWith('...'),
+							type: (dynamic && content.split('=')[1]) || null
+						});
+					});
+					return parts;
+				})
+			);
 
-			if (item.is_layout) {
-				if (item.declares_layout === DEFAULT) {
-					throw new Error(`${project_relative} cannot use reserved "${DEFAULT}" name`);
-				}
+			/** @type {import('types').RouteData} */
+			const route = {
+				id,
+				parent,
 
-				const layout_id = item.declares_layout || DEFAULT;
+				segment,
+				pattern,
+				names,
+				types,
 
-				const group = tree_node(id);
+				layout: null,
+				error: null,
+				leaf: null,
+				page: null,
+				endpoint: null
+			};
 
-				const defined = group.layouts[layout_id] || (group.layouts[layout_id] = {});
+			// important to do this before walking children, so that child
+			// routes appear later
+			route_map.set(id, route);
 
-				if (defined[item.kind] && layout_id !== DEFAULT) {
-					// edge case
-					throw new Error(
-						`Duplicate layout ${project_relative} already defined at ${defined[item.kind]}`
-					);
-				}
+			// if we don't do this, the route map becomes unwieldy to console.log
+			Object.defineProperty(route, 'parent', { enumerable: false });
 
-				defined[item.kind] = project_relative;
+			const dir = path.join(cwd, routes_base, id);
 
-				return;
-			}
+			const files = fs.readdirSync(dir, {
+				withFileTypes: true
+			});
 
-			const type = item.kind === 'server' && !item.is_layout && !item.is_page ? 'endpoint' : 'page';
+			// process files first
+			for (const file of files) {
+				if (file.isDirectory()) continue;
+				if (!file.name.startsWith('+')) continue;
+				if (!valid_extensions.find((ext) => file.name.endsWith(ext))) continue;
 
-			if (type === 'endpoint' && route_map.has(id)) {
-				// note that we are relying on +server being lexically ordered after
-				// all other route files — if we added +view or something this is
-				// potentially brittle, since the server might be added before
-				// another route file. a problem for another day
-				throw new Error(
-					`${file} cannot share a directory with other route files (${project_relative})`
-				);
-			}
+				const project_relative = posixify(path.relative(cwd, path.join(dir, file.name)));
 
-			if (!route_map.has(id)) {
-				const pattern = parse_route_id(id).pattern;
-
-				segment_map.set(
-					id,
-					segments.filter(Boolean).map((segment) => {
-						/** @type {import('./types').Part[]} */
-						const parts = [];
-						segment.split(/\[(.+?)\]/).map((content, i) => {
-							const dynamic = !!(i % 2);
-
-							if (!content) return;
-
-							parts.push({
-								content,
-								dynamic,
-								rest: dynamic && content.startsWith('...'),
-								type: (dynamic && content.split('=')[1]) || null
-							});
-						});
-						return parts;
-					})
+				const item = analyze(
+					project_relative,
+					file.name,
+					config.extensions,
+					config.kit.moduleExtensions
 				);
 
-				if (type === 'endpoint') {
-					route_map.set(id, {
-						type,
-						id,
-						pattern,
-						file: project_relative
-					});
+				if (item.kind === 'component') {
+					if (item.is_error) {
+						route.error = {
+							depth,
+							component: project_relative
+						};
+					} else if (item.is_layout) {
+						if (!route.layout) route.layout = { depth };
+						route.layout.component = project_relative;
+						if (item.uses_layout !== undefined) route.layout.parent_id = item.uses_layout;
+					} else {
+						if (!route.leaf) route.leaf = { depth };
+						route.leaf.component = project_relative;
+						if (item.uses_layout !== undefined) route.leaf.parent_id = item.uses_layout;
+					}
+				} else if (item.is_layout) {
+					if (!route.layout) route.layout = { depth };
+					route.layout[item.kind] = project_relative;
+				} else if (item.is_page) {
+					if (!route.leaf) route.leaf = { depth };
+					route.leaf[item.kind] = project_relative;
 				} else {
-					route_map.set(id, {
-						type,
-						id,
-						pattern,
-						errors: [],
-						layouts: [],
-						leaf: {}
-					});
+					route.endpoint = {
+						file: project_relative
+					};
 				}
 			}
 
-			if (item.is_page) {
-				const route = /** @type {import('types').PageData} */ (route_map.get(id));
-
-				// This ensures that layouts and errors are set for pages that have no Svelte file
-				// and only redirect or throw an error, but are set to the Svelte file definition if it exists.
-				// This ensures the proper error page is used and rendered in the proper layout.
-				if (item.kind === 'component' || route.layouts.length === 0) {
-					const { layouts, errors } = trace(
-						tree,
-						id,
-						item.kind === 'component' ? item.uses_layout : undefined,
-						project_relative
-					);
-					route.layouts = layouts;
-					route.errors = errors;
-				}
-
-				if (item.kind === 'component') {
-					route.leaf.component = project_relative;
-				} else if (item.kind === 'server') {
-					route.leaf.server = project_relative;
-				} else {
-					route.leaf.shared = project_relative;
+			// then handle children
+			for (const file of files) {
+				if (file.isDirectory()) {
+					walk(depth + 1, path.posix.join(id, file.name), file.name, route);
 				}
 			}
-		});
+		};
 
-		// TODO remove for 1.0
-		if (route_map.size === 0) {
-			throw new Error(
-				'The filesystem router API has changed, see https://github.com/sveltejs/kit/discussions/5774 for details'
-			);
-		}
-	}
+		walk(0, '', '', null);
 
-	/** @type {import('types').PageNode[]} */
-	const nodes = [];
+		const root = /** @type {import('types').RouteData} */ (route_map.get(''));
 
-	tree.forEach(({ layouts, error }) => {
-		// we do [default, error, ...other_layouts] so that components[0] and [1]
-		// are the root layout/error. kinda janky, there's probably a nicer way
-		if (layouts[DEFAULT]) {
-			nodes.push(layouts[DEFAULT]);
+		// TODO remove for 1.0
+		if (route_map.size === 1) {
+			if (!root.leaf && !root.error && !root.layout && !root.endpoint) {
+				throw new Error(
+					'The filesystem router API has changed, see https://github.com/sveltejs/kit/discussions/5774 for details'
+				);
+			}
 		}
 
-		if (error) {
-			nodes.push(error);
+		if (!root.layout?.component) {
+			if (!root.layout) root.layout = { depth: 0 };
+			root.layout.component = posixify(path.relative(cwd, `${fallback}/layout.svelte`));
 		}
 
-		for (const id in layouts) {
-			if (id !== DEFAULT) {
-				nodes.push(layouts[id]);
-			}
+		if (!root.error?.component) {
+			if (!root.error) root.error = { depth: 0 };
+			root.error.component = posixify(path.relative(cwd, `${fallback}/error.svelte`));
 		}
-	});
 
-	route_map.forEach((route) => {
-		if (route.type === 'page') {
+		// we do layouts/errors first as they are more likely to be reused,
+		// and smaller indexes take fewer bytes. also, this guarantees that
+		// the default error/layout are 0/1
+		route_map.forEach((route) => {
+			if (route.layout) nodes.push(route.layout);
+			if (route.error) nodes.push(route.error);
+		});
+
+		/** @type {Map<string, string>} */
+		const conflicts = new Map();
+
+		route_map.forEach((route) => {
+			if (!route.leaf) return;
+
 			nodes.push(route.leaf);
-		}
-	});
 
-	const routes = Array.from(route_map.values()).sort((a, b) => compare(a, b, segment_map));
+			const normalized = route.id.split('/').filter(affects_path).join('/');
 
-	/** @type {import('types').Asset[]} */
-	const assets = fs.existsSync(config.kit.files.assets)
-		? list_files(config.kit.files.assets).map((file) => ({
-				file,
-				size: fs.statSync(`${config.kit.files.assets}/${file}`).size,
-				type: mime.getType(file)
-		  }))
-		: [];
+			if (conflicts.has(normalized)) {
+				throw new Error(`${conflicts.get(normalized)} and ${route.id} occupy the same route`);
+			}
 
-	const params_base = path.relative(cwd, config.kit.files.params);
+			conflicts.set(normalized, route.id);
+		});
 
-	/** @type {Record<string, string>} */
-	const matchers = {};
-	if (fs.existsSync(config.kit.files.params)) {
-		for (const file of fs.readdirSync(config.kit.files.params)) {
-			const ext = path.extname(file);
-			if (!config.kit.moduleExtensions.includes(ext)) continue;
-			const type = file.slice(0, -ext.length);
+		const indexes = new Map(nodes.map((node, i) => [node, i]));
 
-			if (/^\w+$/.test(type)) {
-				const matcher_file = path.join(params_base, file);
+		route_map.forEach((route) => {
+			if (!route.leaf) return;
 
-				// Disallow same matcher with different extensions
-				if (matchers[type]) {
-					throw new Error(`Duplicate matchers: ${matcher_file} and ${matchers[type]}`);
-				} else {
-					matchers[type] = matcher_file;
+			if (route.leaf && route.endpoint) {
+				// TODO possibly relax this https://github.com/sveltejs/kit/issues/5896
+				throw new Error(`${route.endpoint.file} cannot share a directory with other route files`);
+			}
+
+			route.page = {
+				layouts: [],
+				errors: [],
+				leaf: /** @type {number} */ (indexes.get(route.leaf))
+			};
+
+			/** @type {import('types').RouteData | null} */
+			let current_route = route;
+			let current_node = route.leaf;
+			let parent_id = route.leaf.parent_id;
+
+			while (current_route) {
+				if (parent_id === undefined || current_route.segment === parent_id) {
+					if (current_route.layout || current_route.error) {
+						route.page.layouts.unshift(
+							current_route.layout ? indexes.get(current_route.layout) : undefined
+						);
+						route.page.errors.unshift(
+							current_route.error ? indexes.get(current_route.error) : undefined
+						);
+					}
+
+					if (current_route.layout) {
+						current_node.parent = current_node = current_route.layout;
+						parent_id = current_node.parent_id;
+					} else {
+						parent_id = undefined;
+					}
 				}
-			} else {
-				throw new Error(
-					`Matcher names can only have underscores and alphanumeric characters — "${file}" is invalid`
-				);
+
+				current_route = current_route.parent;
 			}
-		}
+
+			if (parent_id !== undefined) {
+				throw new Error(`${current_node.component} references missing segment "${parent_id}"`);
+			}
+		});
 	}
 
-	return {
-		assets,
-		nodes,
-		routes,
-		matchers
-	};
+	const routes = Array.from(route_map.values()).sort((a, b) => compare(a, b, segment_map));
+
+	return { nodes, routes };
 }
 
 /**
@@ -288,10 +321,16 @@ function analyze(project_relative, file, component_extensions, module_extensions
 	const component_extension = component_extensions.find((ext) => file.endsWith(ext));
 	if (component_extension) {
 		const name = file.slice(0, -component_extension.length);
-		const pattern =
-			/^\+(?:(page(?:@([a-zA-Z0-9_-]+))?)|(layout(?:-([a-zA-Z0-9_-]+))?(?:@([a-zA-Z0-9_-]+))?)|(error))$/;
+		const pattern = /^\+(?:(page(?:@([a-zA-Z0-9_-]*))?)|(layout(?:@([a-zA-Z0-9_-]*))?)|(error))$/;
 		const match = pattern.exec(name);
 		if (!match) {
+			// TODO remove for 1.0
+			if (/^\+layout-/.test(name)) {
+				throw new Error(
+					`${project_relative} should be reimplemented with layout groups: https://kit.svelte.dev/docs/advanced-routing#advanced-layouts`
+				);
+			}
+
 			throw new Error(`Files prefixed with + are reserved (saw ${project_relative})`);
 		}
 
@@ -299,9 +338,8 @@ function analyze(project_relative, file, component_extensions, module_extensions
 			kind: 'component',
 			is_page: !!match[1],
 			is_layout: !!match[3],
-			is_error: !!match[6],
-			uses_layout: match[2] || match[5],
-			declares_layout: match[4]
+			is_error: !!match[5],
+			uses_layout: match[2] ?? match[4]
 		};
 	}
 
@@ -309,96 +347,29 @@ function analyze(project_relative, file, component_extensions, module_extensions
 	if (module_extension) {
 		const name = file.slice(0, -module_extension.length);
 		const pattern =
-			/^\+(?:(server)|(page(?:@([a-zA-Z0-9_-]+))?(\.server)?)|(layout(?:-([a-zA-Z0-9_-]+))?(?:@([a-zA-Z0-9_-]+))?(\.server)?))$/;
+			/^\+(?:(server)|(page(?:(@[a-zA-Z0-9_-]*))?(\.server)?)|(layout(?:(@[a-zA-Z0-9_-]*))?(\.server)?))$/;
 		const match = pattern.exec(name);
 		if (!match) {
 			throw new Error(`Files prefixed with + are reserved (saw ${project_relative})`);
-		} else if (match[3] || match[7]) {
+		} else if (match[3] || match[6]) {
 			throw new Error(
 				// prettier-ignore
-				`Only Svelte files can reference named layouts. Remove '@${match[3] || match[7]}' from ${file} (at ${project_relative})`
+				`Only Svelte files can reference named layouts. Remove '${match[3] || match[6]}' from ${file} (at ${project_relative})`
 			);
 		}
 
-		const kind = !!(match[1] || match[4] || match[8]) ? 'server' : 'shared';
+		const kind = !!(match[1] || match[4] || match[7]) ? 'server' : 'shared';
 
 		return {
 			kind,
 			is_page: !!match[2],
-			is_layout: !!match[5],
-			declares_layout: match[6]
+			is_layout: !!match[5]
 		};
 	}
 
 	throw new Error(`Files and directories prefixed with + are reserved (saw ${project_relative})`);
 }
 
-/**
- * @param {import('./types').RouteTree} tree
- * @param {string} id
- * @param {string} layout_id
- * @param {string} project_relative
- */
-function trace(tree, id, layout_id = DEFAULT, project_relative) {
-	/** @type {Array<import('types').PageNode | undefined>} */
-	const layouts = [];
-
-	/** @type {Array<import('types').PageNode | undefined>} */
-	const errors = [];
-
-	const parts = id.split('/').filter(Boolean);
-
-	// walk up the tree, find which +layout and +error components
-	// apply to this page
-	while (true) {
-		const node = tree.get(parts.join('/'));
-		const layout = node?.layouts[layout_id];
-
-		if (layout && layouts.indexOf(layout) > -1) {
-			// TODO this needs to be fixed for #5748
-			throw new Error(
-				`Recursive layout detected: ${layout.component} -> ${layouts
-					.map((l) => l?.component)
-					.join(' -> ')}`
-			);
-		}
-
-		// any segment that has neither a +layout nor an +error can be discarded.
-		// in other words these...
-		//  layouts: [a, , b, c]
-		//  errors:  [d, , e,  ]
-		//
-		// ...can be compacted to these:
-		//  layouts: [a, b, c]
-		//  errors:  [d, e,  ]
-		if (node?.error || layout) {
-			errors.unshift(node?.error);
-			layouts.unshift(layout);
-		}
-
-		const parent_layout_id = layout?.component?.split('/').at(-1)?.split('@')[1]?.split('.')[0];
-
-		if (parent_layout_id) {
-			layout_id = parent_layout_id;
-		} else {
-			if (layout) layout_id = DEFAULT;
-			if (parts.length === 0) break;
-			parts.pop();
-		}
-	}
-
-	if (layout_id !== DEFAULT) {
-		throw new Error(`${project_relative} references missing layout "${layout_id}"`);
-	}
-
-	// trim empty space off the end of the errors array
-	let i = errors.length;
-	while (i--) if (errors[i]) break;
-	errors.length = i + 1;
-
-	return { layouts, errors };
-}
-
 /**
  * @param {import('types').RouteData} a
  * @param {import('types').RouteData} b
@@ -445,62 +416,31 @@ function compare(a, b, segment_map) {
 		}
 	}
 
-	const a_is_endpoint = a.type === 'endpoint';
-	const b_is_endpoint = b.type === 'endpoint';
-
-	if (a_is_endpoint !== b_is_endpoint) {
-		return a_is_endpoint ? -1 : +1;
+	if (!!a.endpoint !== !!b.endpoint) {
+		return a.endpoint ? -1 : +1;
 	}
 
 	return a < b ? -1 : 1;
 }
 
-/**
- * @param {string} needle
- * @param {string} haystack
- */
-function count_occurrences(needle, haystack) {
-	let count = 0;
-	for (let i = 0; i < haystack.length; i += 1) {
-		if (haystack[i] === needle) count += 1;
-	}
-	return count;
-}
-
-/**
- * @param {string} dir
- * @param {string} [path]
- * @param {string[]} [files]
- */
-function list_files(dir, path = '', files = []) {
-	fs.readdirSync(dir)
-		.sort((a, b) => {
-			// sort each directory in (+layout, +error, everything else) order
-			// so that we can trace layouts/errors immediately
-
-			if (a.startsWith('+layout') || a.startsWith('+error')) {
-				if (!b.startsWith('+layout') && !b.startsWith('+error')) return -1;
-			} else if (b.startsWith('+layout') || b.startsWith('+error')) {
-				return 1;
-			} else if (a.startsWith('__')) {
-				if (!b.startsWith('__')) return -1;
-			} else if (b.startsWith('__')) {
-				return 1;
-			}
-
-			return a < b ? -1 : 1;
-		})
-		.forEach((file) => {
-			const full = `${dir}/${file}`;
-			const stats = fs.statSync(full);
-			const joined = path ? `${path}/${file}` : file;
-
-			if (stats.isDirectory()) {
-				list_files(full, joined, files);
+/** @param {string} dir */
+function list_files(dir) {
+	/** @type {string[]} */
+	const files = [];
+
+	/** @param {string} current */
+	function walk(current) {
+		for (const file of fs.readdirSync(path.resolve(dir, current))) {
+			const child = path.posix.join(current, file);
+			if (fs.statSync(path.resolve(dir, child)).isDirectory()) {
+				walk(child);
 			} else {
-				files.push(joined);
+				files.push(child);
 			}
-		});
+		}
+	}
+
+	if (fs.existsSync(dir)) walk('');
 
 	return files;
 }