feat: It basically works lol

Author: elliott-with-the-longest-name-on-github

packages/kit/src/core/postbuild/analyse.js

@@ -10,6 +10,7 @@ import { load_config } from '../config/index.js';
 import { forked } from '../../utils/fork.js';
 import { should_polyfill } from '../../utils/platform.js';
 import { installPolyfills } from '../../exports/node/polyfills.js';
+import { route_from_entry } from '../../utils/routing.js';
 
 export default forked(import.meta.url, analyse);
 
@@ -72,6 +73,8 @@ async function analyse({ manifest_path, env }) {
 		let prerender = undefined;
 		/** @type {any} */
 		let config = undefined;
+		/** @type {import('types').PrerenderEntriesGenerator | undefined} */
+		let entries = undefined;
 
 		if (route.endpoint) {
 			const mod = await route.endpoint();
@@ -95,6 +98,7 @@ async function analyse({ manifest_path, env }) {
 			if (mod.OPTIONS) api_methods.push('OPTIONS');
 
 			config = mod.config;
+			entries = mod.entries;
 		}
 
 		if (route.page) {
@@ -125,6 +129,7 @@ async function analyse({ manifest_path, env }) {
 			prerender = get_option(nodes, 'prerender') ?? false;
 
 			config = get_config(nodes);
+			entries = get_option(nodes, 'entries');
 		}
 
 		metadata.routes.set(route.id, {
@@ -136,7 +141,9 @@ async function analyse({ manifest_path, env }) {
 			api: {
 				methods: api_methods
 			},
-			prerender
+			prerender,
+			entries:
+				entries && (await entries()).map((entryObject) => route_from_entry(route.id, entryObject))
 		});
 	}
 

packages/kit/src/core/postbuild/prerender.js

@@ -363,9 +363,18 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 		saved.set(file, dest);
 	}
 
+	/** @type {Array<string>} */
+	const route_level_entries = [];
+	for (const route of metadata.routes.values()) {
+		if (route.entries) {
+			route_level_entries.push(...route.entries);
+		}
+	}
+
 	if (
 		config.prerender.entries.length > 1 ||
 		config.prerender.entries[0] !== '*' ||
+		route_level_entries.length > 0 ||
 		prerender_map.size > 0
 	) {
 		// Only log if we're actually going to do something to not confuse users
@@ -386,6 +395,12 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 		}
 	}
 
+	console.log({ route_level_entries });
+
+	for (const entry of route_level_entries) {
+		enqueue(null, config.paths.base + entry);
+	}
+
 	await q.done();
 
 	// handle invalid fragment links

packages/kit/src/utils/exports.js

@@ -50,15 +50,25 @@ function hint_for_supported_files(key, ext = '.js') {
 	}
 }
 
-const valid_common_exports = ['load', 'prerender', 'csr', 'ssr', 'trailingSlash', 'config'];
+// TODO: Need to distinguish between pages and layouts; should not be able to export entries from layouts
+const valid_common_exports = [
+	'load',
+	'prerender',
+	'csr',
+	'ssr',
+	'trailingSlash',
+	'config',
+	'entries'
+];
 const valid_page_server_exports = [
 	'load',
 	'prerender',
 	'csr',
 	'ssr',
 	'actions',
 	'trailingSlash',
-	'config'
+	'config',
+	'entries'
 ];
 const valid_server_exports = [
 	'GET',
@@ -69,7 +79,8 @@ const valid_server_exports = [
 	'OPTIONS',
 	'prerender',
 	'trailingSlash',
-	'config'
+	'config',
+	'entries'
 ];
 
 export const validate_common_exports = validator(valid_common_exports);

packages/kit/src/utils/options.js

@@ -1,6 +1,6 @@
 /**
- * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash'} Option
- * @template {Option extends 'prerender' ? import('types').PrerenderOption : Option extends 'trailingSlash' ? import('types').TrailingSlash : boolean} Value
+ * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash' | 'entries'} Option
+ * @template {Option extends 'prerender' ? import('types').PrerenderOption : Option extends 'trailingSlash' ? import('types').TrailingSlash : Option extends 'entries' ? import('types').PrerenderEntriesGenerator : boolean} Value
  *
  * @param {Array<import('types').SSRNode | undefined>} nodes
  * @param {Option} option

packages/kit/src/utils/routing.js

@@ -96,6 +96,49 @@ export function parse_route_id(id) {
 	return { pattern, params };
 }
 
+const basic_param_pattern = /\[(\[)?(?:\.\.\.)?(.+?)(?:=(.+))?\]\]?/;
+
+/**
+ * Parses a route ID, then resolves it to a route by replacing parameters with actual values from `entry`.
+ * @param {string} id The route id
+ * @param {Record<string, string>} entry The entry meant to populate the route. For example, if the route is `/blog/[slug]`, the entry would be `{ slug: 'hello-world' }`
+ * @example
+ * ```js
+ * route_from_entry(`/blog/[slug]/[...somethingElse]`, { slug: 'hello-world', somethingElse: 'something/else' }); // `/blog/hello-world/something/else`
+ * ```
+ */
+export function route_from_entry(id, entry) {
+	const segments = get_route_segments(id);
+	return (
+		'/' +
+		segments
+			.map((segment) => {
+				const match = basic_param_pattern.exec(segment);
+
+				// static content -- i.e. not a param
+				if (!match) return segment;
+
+				const optional = !!match[1];
+				const name = match[2];
+				const paramValue = entry[name];
+
+				// If the param is optional and there's no value, don't do anything to the output string
+				if (!paramValue && optional) return '';
+
+				if (!paramValue && !optional)
+					throw new Error(`Missing parameter '${name}' in route '${id}'`);
+
+				if (paramValue.startsWith('/') || paramValue.endsWith('/'))
+					throw new Error(
+						`Parameter '${name}' in route '${id}' cannot start or end with a slash -- this would cause an invalid route like 'foo//bar'`
+					);
+
+				return paramValue;
+			})
+			.join('/')
+	);
+}
+
 /**
  * Returns `false` for `(group)` segments
  * @param {string} segment

packages/kit/types/internal.d.ts

@@ -264,6 +264,7 @@ export interface ServerMetadataRoute {
 	};
 	methods: HttpMethod[];
 	prerender: PrerenderOption | undefined;
+	entries: Array<string> | undefined;
 }
 
 export interface ServerMetadata {
@@ -308,6 +309,7 @@ export interface SSRNode {
 		csr?: boolean;
 		trailingSlash?: TrailingSlash;
 		config?: any;
+		entries?: PrerenderEntriesGenerator;
 	};
 
 	server: {
@@ -318,6 +320,7 @@ export interface SSRNode {
 		trailingSlash?: TrailingSlash;
 		actions?: Actions;
 		config?: any;
+		entries?: PrerenderEntriesGenerator;
 	};
 
 	universal_id: string;
@@ -355,10 +358,13 @@ export interface PageNodeIndexes {
 	leaf: number;
 }
 
+export type PrerenderEntriesGenerator = () => MaybePromise<Array<Record<string, string>>>;
+
 export type SSREndpoint = Partial<Record<HttpMethod, RequestHandler>> & {
 	prerender?: PrerenderOption;
 	trailingSlash?: TrailingSlash;
 	config?: any;
+	entries?: PrerenderEntriesGenerator;
 };
 
 export interface SSRRoute {