@sveltejs/kit 1.0.0-next.298 → 1.0.0-next.299

package/dist/chunks/index2.js

@@ -15,6 +15,7 @@ import 'sade';
 import 'child_process';
 import 'net';
 import 'os';
+import './routing.js';
 import 'node:http';
 import 'node:https';
 import 'node:zlib';
@@ -145,7 +146,6 @@ async function create_build(config) {
  * @param {import('vite').Manifest} manifest
  * @param {Set<string>} css
  * @param {Set<string>} js
- * @returns
  */
 function find_deps(file, manifest, js, css) {
 	const chunk = manifest[file];
@@ -287,7 +287,6 @@ async function build_client({
  *   runtime: string;
  *   template: string;
  * }} opts
- * @returns
  */
 const server_template = ({ config, hooks, has_service_worker, runtime, template }) => `
 import root from '__GENERATED__/root.svelte';
@@ -424,7 +423,7 @@ async function build_server(
 		}
 	});
 
-	// ...and every component used by pages
+	// ...and every component used by pages...
 	manifest_data.components.forEach((file) => {
 		const resolved = path__default.resolve(cwd, file);
 		const relative = path__default.relative(config.kit.files.routes, resolved);
@@ -435,6 +434,12 @@ async function build_server(
 		input[name] = resolved;
 	});
 
+	// ...and every validator
+	Object.entries(manifest_data.validators).forEach(([key, file]) => {
+		const name = posixify(path__default.join('entries/validators', key));
+		input[name] = path__default.resolve(cwd, file);
+	});
+
 	/** @type {(file: string) => string} */
 	const app_relative = (file) => {
 		const relative_file = path__default.relative(build_dir, path__default.resolve(cwd, file));
@@ -577,7 +582,6 @@ const method_names = {
 };
 
 /**
- *
  * @param {string} cwd
  * @param {import('rollup').OutputChunk[]} output
  * @param {import('types').ManifestData} manifest_data

package/dist/chunks/index3.js

@@ -1,4 +1,5 @@
 import { s } from './misc.js';
+import { p as parse_route_id } from './routing.js';
 import { a as get_mime_lookup } from '../cli.js';
 
 /**
@@ -41,10 +42,13 @@ function generate_manifest({ build_data, relative_path, routes, format = 'esm' }
 	});
 
 	/** @type {(path: string) => string} */
-	const importer =
+	const load =
 		format === 'esm'
-			? (path) => `() => import('${path}')`
-			: (path) => `() => Promise.resolve().then(() => require('${path}'))`;
+			? (path) => `import('${path}')`
+			: (path) => `Promise.resolve().then(() => require('${path}'))`;
+
+	/** @type {(path: string) => string} */
+	const loader = (path) => `() => ${load(path)}`;
 
 	const assets = build_data.manifest_data.assets.map((asset) => asset.file);
 	if (build_data.service_worker) {
@@ -54,6 +58,8 @@ function generate_manifest({ build_data, relative_path, routes, format = 'esm' }
 	/** @param {string} id */
 	const get_index = (id) => id && /** @type {LookupEntry} */ (bundled_nodes.get(id)).index;
 
+	const validators = new Set();
+
 	// prettier-ignore
 	return `{
 		appDir: ${s(build_data.app_dir)},
@@ -62,18 +68,25 @@ function generate_manifest({ build_data, relative_path, routes, format = 'esm' }
 		_: {
 			entry: ${s(build_data.client.entry)},
 			nodes: [
-				${Array.from(bundled_nodes.values()).map(node => importer(node.path)).join(',\n\t\t\t\t')}
+				${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) validators.add(type);
+					});
+
 					if (route.type === 'page') {
 						return `{
 							type: 'page',
-							key: ${s(route.key)},
-							pattern: ${route.pattern},
-							params: ${get_params(route.params)},
+							id: ${s(route.id)},
+							pattern: ${pattern},
+							names: ${s(names)},
+							types: ${s(types)},
 							path: ${route.path ? s(route.path) : null},
-							shadow: ${route.shadow ? importer(`${relative_path}/${build_data.server.vite_manifest[route.shadow].file}`) : 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, '');
@@ -86,33 +99,21 @@ function generate_manifest({ build_data, relative_path, routes, format = 'esm' }
 
 						return `{
 							type: 'endpoint',
-							pattern: ${route.pattern},
-							params: ${get_params(route.params)},
-							load: ${importer(`${relative_path}/${build_data.server.vite_manifest[route.file].file}`)}
+							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, '');
 					}
 				}).filter(Boolean).join(',\n\t\t\t\t')}
-			]
+			],
+			validators: async () => {
+				${Array.from(validators).map(type => `const { validate: ${type} } = await ${load(`${relative_path}/entries/validators/${type}.js`)}`).join('\n\t\t\t\t')}
+				return { ${Array.from(validators).join(', ')} };
+			}
 		}
 	}`.replace(/^\t/gm, '');
 }
 
-/** @param {string[]} array */
-function get_params(array) {
-	// given an array of params like `['x', 'y', 'z']` for
-	// src/routes/[x]/[y]/[z]/svelte, create a function
-	// that turns a RexExpMatchArray into ({ x, y, z })
-	return array.length
-		? '(m) => ({ ' +
-				array
-					.map((param, i) => {
-						return param.startsWith('...')
-							? `${param.slice(3)}: m[${i + 1}] || ''`
-							: `${param}: m[${i + 1}]`;
-					})
-					.join(', ') +
-				'})'
-		: 'null';
-}
-
 export { generate_manifest as g };

package/dist/chunks/index4.js

@@ -9,6 +9,7 @@ import 'fs';
 import 'url';
 import 'os';
 import './misc.js';
+import './routing.js';
 
 /**
  * @param {{

package/dist/chunks/routing.js

@@ -0,0 +1,39 @@
+/** @param {string} key */
+function parse_route_id(key) {
+	/** @type {string[]} */
+	const names = [];
+
+	/** @type {string[]} */
+	const types = [];
+
+	const pattern =
+		key === ''
+			? /^\/$/
+			: new RegExp(
+					`^${decodeURIComponent(key)
+						.split('/')
+						.map((segment) => {
+							// special case — /[...rest]/ could contain zero segments
+							const match = /^\[\.\.\.(\w+)(?:=\w+)?\]$/.exec(segment);
+							if (match) {
+								names.push(match[1]);
+								types.push(match[2]);
+								return '(?:/(.*))?';
+							}
+
+							return (
+								'/' +
+								segment.replace(/\[(\.\.\.)?(\w+)(?:=(\w+))?\]/g, (m, rest, name, type) => {
+									names.push(name);
+									types.push(type);
+									return rest ? '(.*?)' : '([^/]+?)';
+								})
+							);
+						})
+						.join('')}/?$`
+			  );
+
+	return { pattern, names, types };
+}
+
+export { parse_route_id as p };

package/dist/chunks/sync.js

@@ -119,6 +119,7 @@ var mime = new Mime(standard, other);
  *   content: string;
  *   dynamic: boolean;
  *   rest: boolean;
+ *   type: string | null;
  * }} Part
  * @typedef {{
  *   basename: string;
@@ -168,13 +169,13 @@ function create_manifest_data({
 
 	/**
 	 * @param {string} dir
-	 * @param {string[]} parent_key
+	 * @param {string[]} parent_id
 	 * @param {Part[][]} parent_segments
 	 * @param {string[]} parent_params
 	 * @param {Array<string|undefined>} layout_stack // accumulated __layout.svelte components
 	 * @param {Array<string|undefined>} error_stack // accumulated __error.svelte components
 	 */
-	function walk(dir, parent_key, parent_segments, parent_params, layout_stack, error_stack) {
+	function walk(dir, parent_id, parent_segments, parent_params, layout_stack, error_stack) {
 		/** @type {Item[]} */
 		let items = [];
 		fs__default.readdirSync(dir).forEach((basename) => {
@@ -242,7 +243,7 @@ function create_manifest_data({
 		items = items.sort(comparator);
 
 		items.forEach((item) => {
-			const key = parent_key.slice();
+			const id = parent_id.slice();
 			const segments = parent_segments.slice();
 
 			if (item.is_index) {
@@ -255,24 +256,26 @@ function create_manifest_data({
 							last_segment.push({
 								dynamic: false,
 								rest: false,
-								content: item.route_suffix
+								content: item.route_suffix,
+								type: null
 							});
 						} else {
 							last_segment[last_segment.length - 1] = {
 								dynamic: false,
 								rest: false,
-								content: `${last_part.content}${item.route_suffix}`
+								content: `${last_part.content}${item.route_suffix}`,
+								type: null
 							};
 						}
 
 						segments[segments.length - 1] = last_segment;
-						key[key.length - 1] += item.route_suffix;
+						id[id.length - 1] += item.route_suffix;
 					} else {
 						segments.push(item.parts);
 					}
 				}
 			} else {
-				key.push(item.name);
+				id.push(item.name);
 				segments.push(item.parts);
 			}
 
@@ -306,7 +309,7 @@ function create_manifest_data({
 
 				walk(
 					path__default.join(dir, item.basename),
-					key,
+					id,
 					segments,
 					params,
 					layout_reset ? [layout_reset] : layout_stack.concat(layout),
@@ -341,7 +344,7 @@ function create_manifest_data({
 
 				routes.push({
 					type: 'page',
-					key: key.join('/'),
+					id: id.join('/'),
 					segments: simple_segments,
 					pattern,
 					params,
@@ -355,7 +358,7 @@ function create_manifest_data({
 
 				routes.push({
 					type: 'endpoint',
-					key: key.join('/'),
+					id: id.join('/'),
 					segments: simple_segments,
 					pattern,
 					file: item.file,
@@ -365,10 +368,10 @@ function create_manifest_data({
 		});
 	}
 
-	const base = path__default.relative(cwd, config.kit.files.routes);
+	const routes_base = path__default.relative(cwd, config.kit.files.routes);
 
-	const layout = find_layout('__layout', base) || default_layout;
-	const error = find_layout('__error', base) || default_error;
+	const layout = find_layout('__layout', routes_base) || default_layout;
+	const error = find_layout('__error', routes_base) || default_error;
 
 	components.push(layout, error);
 
@@ -377,15 +380,15 @@ function create_manifest_data({
 	const lookup = new Map();
 	for (const route of routes) {
 		if (route.type === 'page') {
-			lookup.set(route.key, route);
+			lookup.set(route.id, route);
 		}
 	}
 
 	let i = routes.length;
 	while (i--) {
 		const route = routes[i];
-		if (route.type === 'endpoint' && lookup.has(route.key)) {
-			lookup.get(route.key).shadow = route.file;
+		if (route.type === 'endpoint' && lookup.has(route.id)) {
+			lookup.get(route.id).shadow = route.file;
 			routes.splice(i, 1);
 		}
 	}
@@ -394,12 +397,32 @@ function create_manifest_data({
 		? list_files({ config, dir: config.kit.files.assets, path: '' })
 		: [];
 
+	const params_base = path__default.relative(cwd, config.kit.files.params);
+
+	/** @type {Record<string, string>} */
+	const validators = {};
+	if (fs__default.existsSync(config.kit.files.params)) {
+		for (const file of fs__default.readdirSync(config.kit.files.params)) {
+			const ext = path__default.extname(file);
+			const type = file.slice(0, -ext.length);
+
+			if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(type)) {
+				validators[type] = path__default.join(params_base, file);
+			} else {
+				throw new Error(
+					`Validator names must match /^[a-zA-Z_][a-zA-Z0-9_]*$/ — "${file}" is invalid`
+				);
+			}
+		}
+	}
+
 	return {
 		assets,
 		layout,
 		error,
 		components,
-		routes
+		routes,
+		validators
 	};
 }
 
@@ -456,6 +479,10 @@ function comparator(a, b) {
 			return a_sub_part.dynamic ? 1 : -1;
 		}
 
+		if (a_sub_part.dynamic && !!a_sub_part.type !== !!b_sub_part.type) {
+			return a_sub_part.type ? -1 : 1;
+		}
+
 		if (!a_sub_part.dynamic && a_sub_part.content !== b_sub_part.content) {
 			return (
 				b_sub_part.content.length - a_sub_part.content.length ||
@@ -483,16 +510,25 @@ function get_parts(part, file) {
 		if (!str) return;
 		const dynamic = i % 2 === 1;
 
-		const [, content] = dynamic ? /([^(]+)$/.exec(str) || [null, null] : [null, str];
-
-		if (!content || (dynamic && !/^(\.\.\.)?[a-zA-Z0-9_$]+$/.test(content))) {
-			throw new Error(`Invalid route ${file} — parameter name must match /^[a-zA-Z0-9_$]+$/`);
+		const [, content, type] = dynamic
+			? /^((?:\.\.\.)?[a-zA-Z_][a-zA-Z0-9_]*)(?:=([a-zA-Z_][a-zA-Z0-9_]*))?$/.exec(str) || [
+					null,
+					null,
+					null
+			  ]
+			: [null, str, null];
+
+		if (!content) {
+			throw new Error(
+				`Invalid route ${file} — parameter name and type must match /^[a-zA-Z_][a-zA-Z0-9_]*$/`
+			);
 		}
 
 		result.push({
 			content,
 			dynamic,
-			rest: dynamic && /^\.{3}.+$/.test(content)
+			rest: dynamic && /^\.{3}.+$/.test(content),
+			type
 		});
 	});
 
@@ -640,49 +676,30 @@ function write_manifest(manifest_data, base, output) {
 
 	/** @param {string[]} parts */
 	const get_indices = (parts) =>
-		`[${parts.map((part) => (part ? `c[${component_indexes[part]}]` : '')).join(', ')}]`;
+		`[${parts.map((part) => (part ? component_indexes[part] : '')).join(', ')}]`;
 
-	const routes = `[
+	const dictionary = `{
 		${manifest_data.routes
 			.map((route) => {
 				if (route.type === 'page') {
-					const params =
-						route.params.length > 0 &&
-						'(m) => ({ ' +
-							route.params
-								.map((param, i) => {
-									return param.startsWith('...')
-										? `${param.slice(3)}: d(m[${i + 1}] || '')`
-										: `${param}: d(m[${i + 1}])`;
-								})
-								.join(', ') +
-							'})';
-
-					const tuple = [route.pattern, get_indices(route.a), get_indices(route.b)];
-
-					// optional items
-					if (params || route.shadow) tuple.push(params || 'null');
-					if (route.shadow) tuple.push(`'${route.key}'`);
-
-					return `// ${route.a[route.a.length - 1]}\n\t\t[${tuple.join(', ')}]`;
+					const tuple = [get_indices(route.a), get_indices(route.b)];
+					if (route.shadow) tuple.push('1');
+
+					return `${s(route.id)}: [${tuple.join(', ')}]`;
 				}
 			})
 			.filter(Boolean)
-			.join(',\n\n\t\t')}
-	]`.replace(/^\t/gm, '');
+			.join(',\n\t\t')}
+	}`.replace(/^\t/gm, '');
 
 	write_if_changed(
-		`${output}/manifest.js`,
+		`${output}/client-manifest.js`,
 		trim(`
-			const c = ${components};
-
-			const d = decodeURIComponent;
+			export { validators } from './client-validators.js';
 
-			export const routes = ${routes};
+			export const components = ${components};
 
-			// we import the root layout/error components eagerly, so that
-			// connectivity errors after initialisation don't nuke the app
-			export const fallback = [c[0](), c[1]()];
+			export const dictionary = ${dictionary};
 		`)
 	);
 }
@@ -986,6 +1003,28 @@ function write_types(config, manifest_data) {
 	});
 }
 
+/**
+ * @param {import('types').ManifestData} manifest_data
+ * @param {string} output
+ */
+function write_validators(manifest_data, output) {
+	const imports = [];
+	const validators = [];
+
+	for (const key in manifest_data.validators) {
+		const src = manifest_data.validators[key];
+
+		imports.push(`import { validate as ${key} } from ${s(path__default.relative(output, src))};`);
+		validators.push(key);
+	}
+
+	const module = imports.length
+		? `${imports.join('\n')}\n\nexport const validators = { ${validators.join(', ')} };`
+		: 'export const validators = {};';
+
+	write_if_changed(`${output}/client-validators.js`, module);
+}
+
 /** @param {import('types').ValidatedConfig} config */
 function init(config) {
 	copy_assets(path__default.join(config.kit.outDir, 'runtime'));
@@ -1001,6 +1040,7 @@ function update(config) {
 
 	write_manifest(manifest_data, base, output);
 	write_root(manifest_data, output);
+	write_validators(manifest_data, output);
 	write_types(config, manifest_data);
 
 	return { manifest_data };

package/dist/cli.js

@@ -403,6 +403,7 @@ const options = object(
 				assets: string('static'),
 				hooks: string(join('src', 'hooks')),
 				lib: string(join('src', 'lib')),
+				params: string(join('src', 'params')),
 				routes: string(join('src', 'routes')),
 				serviceWorker: string(join('src', 'service-worker')),
 				template: string(join('src', 'app.html'))
@@ -787,12 +788,10 @@ async function load_config({ cwd = process.cwd() } = {}) {
 
 	validated.kit.outDir = path__default.resolve(cwd, validated.kit.outDir);
 
-	validated.kit.files.assets = path__default.resolve(cwd, validated.kit.files.assets);
-	validated.kit.files.hooks = path__default.resolve(cwd, validated.kit.files.hooks);
-	validated.kit.files.lib = path__default.resolve(cwd, validated.kit.files.lib);
-	validated.kit.files.routes = path__default.resolve(cwd, validated.kit.files.routes);
-	validated.kit.files.serviceWorker = path__default.resolve(cwd, validated.kit.files.serviceWorker);
-	validated.kit.files.template = path__default.resolve(cwd, validated.kit.files.template);
+	for (const key in validated.kit.files) {
+		// @ts-expect-error this is typescript at its stupidest
+		validated.kit.files[key] = path__default.resolve(cwd, validated.kit.files[key]);
+	}
 
 	return validated;
 }
@@ -870,7 +869,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.298');
+const prog = sade('svelte-kit').version('1.0.0-next.299');
 
 prog
 	.command('dev')
@@ -1043,7 +1042,7 @@ async function check_port(port) {
 function welcome({ port, host, https, open, loose, allow, cwd }) {
 	if (open) launch(port, https);
 
-	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.298'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.299'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.298",
+  "version": "1.0.0-next.299",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/types/index.d.ts

@@ -7,9 +7,7 @@ import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import {
 	AdapterEntry,
 	CspDirectives,
-	Either,
 	ErrorLoadInput,
-	Fallthrough,
 	JSONValue,
 	LoadInput,
 	LoadOutput,
@@ -114,6 +112,7 @@ export interface Config {
 			assets?: string;
 			hooks?: string;
 			lib?: string;
+			params?: string;
 			routes?: string;
 			serviceWorker?: string;
 			template?: string;
@@ -194,9 +193,7 @@ export interface Load<
 	InputProps extends Record<string, any> = Record<string, any>,
 	OutputProps extends Record<string, any> = InputProps
 > {
-	(input: LoadInput<Params, InputProps>): MaybePromise<
-		Either<Fallthrough, LoadOutput<OutputProps>>
-	>;
+	(input: LoadInput<Params, InputProps>): MaybePromise<LoadOutput<OutputProps>>;
 }
 
 export interface Navigation {
@@ -207,11 +204,16 @@ export interface Navigation {
 export interface Page<Params extends Record<string, string> = Record<string, string>> {
 	url: URL;
 	params: Params;
+	routeId: string | null;
 	stuff: App.Stuff;
 	status: number;
 	error: Error | null;
 }
 
+export interface ParamValidator {
+	(param: string): boolean;
+}
+
 /**
  * A function exported from an endpoint that corresponds to an
  * HTTP verb (`get`, `put`, `patch`, etc) and handles requests with
@@ -228,16 +230,11 @@ export interface RequestHandler<
 	(event: RequestEvent<Params>): RequestHandlerOutput<Output>;
 }
 
-export type RequestHandlerOutput<Output extends ResponseBody = ResponseBody> = MaybePromise<
-	Either<
-		{
-			status?: number;
-			headers?: Headers | Partial<ResponseHeaders>;
-			body?: Output;
-		},
-		Fallthrough
-	>
->;
+export type RequestHandlerOutput<Output extends ResponseBody = ResponseBody> = MaybePromise<{
+	status?: number;
+	headers?: Headers | Partial<ResponseHeaders>;
+	body?: Output;
+}>;
 
 export type ResponseBody = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
 
@@ -260,5 +257,6 @@ export interface SSRManifest {
 		};
 		nodes: SSRNodeLoader[];
 		routes: SSRRoute[];
+		validators: () => Promise<Record<string, ParamValidator>>;
 	};
 }