@sveltejs/kit 1.0.0-next.55 → 1.0.0-next.550

package/src/utils/routing.js

@@ -0,0 +1,168 @@
+const param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
+
+/**
+ * Creates the regex pattern, extracts parameter names, and generates types for a route
+ * @param {string} id
+ */
+export function parse_route_id(id) {
+	/** @type {string[]} */
+	const names = [];
+
+	/** @type {string[]} */
+	const types = [];
+
+	/** @type {boolean[]} */
+	const optional = [];
+
+	// `/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(
+					`^${get_route_segments(id)
+						.map((segment, i, segments) => {
+							// special case — /[...rest]/ could contain zero segments
+							const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
+							if (rest_match) {
+								names.push(rest_match[1]);
+								types.push(rest_match[2]);
+								optional.push(false);
+								return '(?:/(.*))?';
+							}
+							// special case — /[[optional]]/ could contain zero segments
+							const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment);
+							if (optional_match) {
+								names.push(optional_match[1]);
+								types.push(optional_match[2]);
+								optional.push(true);
+								return '(?:/([^/]+))?';
+							}
+
+							const is_last = i === segments.length - 1;
+
+							if (!segment) {
+								return;
+							}
+
+							const parts = segment.split(/\[(.+?)\](?!\])/);
+							const result = parts
+								.map((content, i) => {
+									if (i % 2) {
+										if (content.startsWith('x+')) {
+											return escape(String.fromCharCode(parseInt(content.slice(2), 16)));
+										}
+
+										if (content.startsWith('u+')) {
+											return escape(
+												String.fromCharCode(
+													...content
+														.slice(2)
+														.split('-')
+														.map((code) => parseInt(code, 16))
+												)
+											);
+										}
+
+										const match = param_pattern.exec(content);
+										if (!match) {
+											throw new Error(
+												`Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.`
+											);
+										}
+
+										const [, is_optional, is_rest, name, type] = match;
+										// It's assumed that the following invalid route id cases are already checked
+										// - unbalanced brackets
+										// - optional param following rest param
+
+										names.push(name);
+										types.push(type);
+										optional.push(!!is_optional);
+										return is_rest ? '(.*?)' : is_optional ? '([^/]*)?' : '([^/]+?)';
+									}
+
+									if (is_last && content.includes('.')) add_trailing_slash = false;
+
+									return escape(content);
+								})
+								.join('');
+
+							return '/' + result;
+						})
+						.join('')}${add_trailing_slash ? '/?' : ''}$`
+			  );
+
+	return { pattern, names, types, optional };
+}
+
+/**
+ * Returns `false` for `(group)` segments
+ * @param {string} segment
+ */
+function affects_path(segment) {
+	return !/^\([^)]+\)$/.test(segment);
+}
+
+/**
+ * Splits a route id into its segments, removing segments that
+ * don't affect the path (i.e. groups). The root route is represented by `/`
+ * and will be returned as `['']`.
+ * @param {string} route
+ * @returns string[]
+ */
+export function get_route_segments(route) {
+	return route.slice(1).split('/').filter(affects_path);
+}
+
+/**
+ * @param {RegExpMatchArray} match
+ * @param {{
+ *   names: string[];
+ *   types: string[];
+ *   optional: boolean[];
+ * }} candidate
+ * @param {Record<string, import('types').ParamMatcher>} matchers
+ */
+export function exec(match, { names, types, optional }, matchers) {
+	/** @type {Record<string, string>} */
+	const params = {};
+
+	for (let i = 0; i < names.length; i += 1) {
+		const name = names[i];
+		const type = types[i];
+		let value = match[i + 1];
+
+		if (value || !optional[i]) {
+			if (type) {
+				const matcher = matchers[type];
+				if (!matcher) throw new Error(`Missing "${type}" param matcher`); // TODO do this ahead of time?
+
+				if (!matcher(value)) return;
+			}
+
+			params[name] = value ?? '';
+		}
+	}
+
+	return params;
+}
+
+/** @param {string} str */
+function escape(str) {
+	return (
+		str
+			.normalize()
+			// escape [ and ] before escaping other characters, since they are used in the replacements
+			.replace(/[[\]]/g, '\\$&')
+			// replace %, /, ? and # with their encoded versions because decode_pathname leaves them untouched
+			.replace(/%/g, '%25')
+			.replace(/\//g, '%2[Ff]')
+			.replace(/\?/g, '%3[Ff]')
+			.replace(/#/g, '%23')
+			// escape characters that have special meaning in regex
+			.replace(/[.*+?^${}()|\\]/g, '\\$&')
+	);
+}

package/src/utils/unit_test.js

@@ -0,0 +1,11 @@
+import { suite } from 'uvu';
+
+/**
+ * @param {string} name
+ * @param {(suite: import('uvu').Test<import('uvu').Context>) => void} fn
+ */
+export function describe(name, fn) {
+	const s = suite(name);
+	fn(s);
+	s.run();
+}

package/src/utils/url.js

@@ -0,0 +1,159 @@
+const absolute = /^([a-z]+:)?\/?\//;
+const scheme = /^[a-z]+:/;
+
+/**
+ * @param {string} base
+ * @param {string} path
+ */
+export function resolve(base, path) {
+	if (scheme.test(path)) return path;
+	if (path[0] === '#') return base + path;
+
+	const base_match = absolute.exec(base);
+	const path_match = absolute.exec(path);
+
+	if (!base_match) {
+		throw new Error(`bad base path: "${base}"`);
+	}
+
+	const baseparts = path_match ? [] : base.slice(base_match[0].length).split('/');
+	const pathparts = path_match ? path.slice(path_match[0].length).split('/') : path.split('/');
+
+	baseparts.pop();
+
+	for (let i = 0; i < pathparts.length; i += 1) {
+		const part = pathparts[i];
+		if (part === '.') continue;
+		else if (part === '..') baseparts.pop();
+		else baseparts.push(part);
+	}
+
+	const prefix = (path_match && path_match[0]) || (base_match && base_match[0]) || '';
+
+	return `${prefix}${baseparts.join('/')}`;
+}
+
+/** @param {string} path */
+export function is_root_relative(path) {
+	return path[0] === '/' && path[1] !== '/';
+}
+
+/**
+ * @param {string} path
+ * @param {import('types').TrailingSlash} trailing_slash
+ */
+export function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && !path.endsWith('/')) {
+		return path + '/';
+	}
+
+	return path;
+}
+
+/**
+ * Decode pathname excluding %25 to prevent further double decoding of params
+ * @param {string} pathname
+ */
+export function decode_pathname(pathname) {
+	return pathname.split('%25').map(decodeURI).join('%25');
+}
+
+/** @param {Record<string, string>} params */
+export function decode_params(params) {
+	for (const key in params) {
+		// input has already been decoded by decodeURI
+		// now handle the rest
+		params[key] = decodeURIComponent(params[key]);
+	}
+
+	return params;
+}
+
+/**
+ * URL properties that could change during the lifetime of the page,
+ * which excludes things like `origin`
+ * @type {Array<keyof URL>}
+ */
+const tracked_url_properties = ['href', 'pathname', 'search', 'searchParams', 'toString', 'toJSON'];
+
+/**
+ * @param {URL} url
+ * @param {() => void} callback
+ */
+export function make_trackable(url, callback) {
+	const tracked = new URL(url);
+
+	for (const property of tracked_url_properties) {
+		let value = tracked[property];
+
+		Object.defineProperty(tracked, property, {
+			get() {
+				callback();
+				return value;
+			},
+
+			enumerable: true,
+			configurable: true
+		});
+	}
+
+	if (!__SVELTEKIT_BROWSER__) {
+		// @ts-ignore
+		tracked[Symbol.for('nodejs.util.inspect.custom')] = (depth, opts, inspect) => {
+			return inspect(url, opts);
+		};
+	}
+
+	disable_hash(tracked);
+
+	return tracked;
+}
+
+/**
+ * Disallow access to `url.hash` on the server and in `load`
+ * @param {URL} url
+ */
+export function disable_hash(url) {
+	Object.defineProperty(url, 'hash', {
+		get() {
+			throw new Error(
+				'Cannot access event.url.hash. Consider using `$page.url.hash` inside a component instead'
+			);
+		}
+	});
+}
+
+/**
+ * Disallow access to `url.search` and `url.searchParams` during prerendering
+ * @param {URL} url
+ */
+export function disable_search(url) {
+	for (const property of ['search', 'searchParams']) {
+		Object.defineProperty(url, property, {
+			get() {
+				throw new Error(`Cannot access url.${property} on a page with prerendering enabled`);
+			}
+		});
+	}
+}
+
+const DATA_SUFFIX = '/__data.json';
+
+/** @param {string} pathname */
+export function has_data_suffix(pathname) {
+	return pathname.endsWith(DATA_SUFFIX);
+}
+
+/** @param {string} pathname */
+export function add_data_suffix(pathname) {
+	return pathname.replace(/\/$/, '') + DATA_SUFFIX;
+}
+
+/** @param {string} pathname */
+export function strip_data_suffix(pathname) {
+	return pathname.slice(0, -DATA_SUFFIX.length);
+}

package/svelte-kit.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import './dist/cli.js';
+import './src/cli.js';