@vigla/kit 0.0.0-stage → 0.1.0

package/src/shared/remote.ts

@@ -0,0 +1,162 @@
+import { parse, stringify, stringifyAsync } from 'devalue';
+import type { Transport } from '../types/hooks.ts';
+import { decoders, encoders, type Decoders, type Encoders } from './serialization.ts';
+import * as errors from './errors.ts';
+
+const objectType = '__skrao';
+const mapType = '__skram';
+const setType = '__skras';
+const fileType = '__skraf';
+const prototypeKeys = Object.getOwnPropertyNames(Object.prototype).sort().join('\0');
+
+function isPlain(value: unknown): value is Record<string, unknown> {
+	if (!value || typeof value !== 'object') return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (
+		prototype === null ||
+		prototype === Object.prototype ||
+		Object.getPrototypeOf(prototype) === null ||
+		Object.getOwnPropertyNames(prototype).sort().join('\0') === prototypeKeys
+	);
+}
+
+function reducers(transport: Transport, canonical: boolean): Encoders {
+	const codecs: Encoders = {
+		...encoders(transport),
+		__skrag(value) {
+			if (value instanceof RegExp)
+				errors.remote_argument_unsupported({ type: 'Regular expressions' });
+		}
+	};
+	if (canonical) {
+		const originals = new Map<object, Record<string, unknown>>();
+		const sorted = new Set<object>();
+		const encode = (value: unknown) => stringify(value, codecs);
+		codecs[mapType] = (value: unknown) =>
+			value instanceof Map
+				? [...value]
+						.map(([key, item]): [string, string] => [encode(key), encode(item)])
+						.sort(([a, b], [c, d]) => (a < c ? -1 : a > c ? 1 : b < d ? -1 : b > d ? 1 : 0))
+				: undefined;
+		codecs[setType] = (value: unknown) =>
+			value instanceof Set ? [...value].map(encode).sort() : undefined;
+		codecs[objectType] = (value: unknown) => {
+			if (!isPlain(value) || sorted.has(value)) return;
+			const previous = originals.get(value);
+			if (previous) return previous;
+			const clone = Object.create(Object.getPrototypeOf(value) === null ? null : Object.prototype);
+			originals.set(value, clone);
+			sorted.add(clone);
+			for (const key of Object.keys(value).sort()) {
+				const item = value[key];
+				Object.defineProperty(clone, key, {
+					value: originals.get(item as object) ?? item,
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			return clone;
+		};
+	}
+	return codecs;
+}
+
+function revivers(transport: Transport): Decoders {
+	const codecs: Decoders = {
+		...decoders(transport),
+		[objectType]: (value) => value,
+		[mapType](value: unknown) {
+			if (
+				!Array.isArray(value) ||
+				value.some(
+					(entry) =>
+						!Array.isArray(entry) ||
+						entry.length !== 2 ||
+						entry.some((item) => typeof item !== 'string')
+				)
+			) {
+				throw new Error('Invalid data for Map reviver');
+			}
+			return new Map(value.map(([key, item]) => [parse(key, codecs), parse(item, codecs)]));
+		},
+		[setType](value: unknown) {
+			if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+				throw new Error('Invalid data for Set reviver');
+			}
+			return new Set(value.map((item) => parse(item, codecs)));
+		},
+		[fileType](value: any) {
+			if (
+				!value ||
+				typeof value.name !== 'string' ||
+				typeof value.type !== 'string' ||
+				typeof value.size !== 'number' ||
+				typeof value.lastModified !== 'number' ||
+				!(value.data instanceof ArrayBuffer)
+			)
+				throw new Error('Invalid data for File reviver');
+			return new File([value.data], value.name, {
+				type: value.type,
+				lastModified: value.lastModified
+			});
+		}
+	};
+	return codecs;
+}
+
+function base64url(value: string): string {
+	const bytes = new TextEncoder().encode(value);
+	let binary = '';
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replaceAll('=', '').replaceAll('+', '-').replaceAll('/', '_');
+}
+
+export function encodeArgument(value: unknown, transport: Transport = {}): string {
+	return value === undefined ? '' : base64url(stringify(value, reducers(transport, true)));
+}
+
+export async function encodeCommand(value: unknown, transport: Transport = {}): Promise<string> {
+	if (value === undefined) return '';
+	const codecs = reducers(transport, false);
+	const files = new Set<Promise<unknown>>();
+	codecs[fileType] = (value: unknown) => {
+		if (!(value instanceof File)) return;
+		const pending = value.arrayBuffer().then((data) => ({
+			data,
+			lastModified: value.lastModified,
+			name: value.name,
+			size: value.size,
+			type: value.type
+		}));
+		files.add(pending);
+		return pending;
+	};
+	codecs.__skrap = (value: unknown) => {
+		if (value instanceof Promise && !files.has(value))
+			errors.remote_argument_unsupported({ type: 'Promises' });
+	};
+	return base64url(await stringifyAsync(value, codecs));
+}
+
+export function decodeArgument(payload: string | null, transport: Transport = {}): any {
+	if (!payload) return undefined;
+	const binary = atob(payload.replaceAll('-', '+').replaceAll('_', '/'));
+	const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+	return parse(new TextDecoder().decode(bytes), revivers(transport));
+}
+
+export function getRemoteKey(id: string, payload: string): string {
+	return `${id}/${payload}`;
+}
+
+export interface RemoteKey {
+	id: string;
+	payload: string;
+}
+
+export function splitRemoteKey(key: string): RemoteKey {
+	const slash = key.lastIndexOf('/');
+	if (slash === -1) throw new Error(`Invalid remote key: ${key}`);
+	return { id: key.slice(0, slash), payload: key.slice(slash + 1) };
+}

package/src/shared/render.ts

@@ -0,0 +1,13 @@
+export function errorGuards(
+	depths: readonly number[],
+	errors: readonly unknown[]
+): Array<number | undefined> {
+	let floor = 0;
+	return depths.map((depth, index) => {
+		if (index === 0) return undefined;
+		let guard = depth - 1;
+		while (guard > floor && errors[guard] == null) guard--;
+		floor = guard + 1;
+		return errors[guard] == null ? undefined : guard;
+	});
+}

package/src/shared/routing/index.ts

@@ -0,0 +1,11 @@
+export {
+	parseRoute,
+	resolveRoute,
+	routeSegments,
+	invalidParam,
+	decodeEscape,
+	encodePathChars
+} from './pattern.ts';
+export { exec, findRoute } from './match.ts';
+export type { RouteMatch } from './match.ts';
+export { sortRoutes } from './sort.ts';

package/src/shared/routing/match.ts

@@ -0,0 +1,76 @@
+import type { ParamMatcher, ParamValue } from '../../types/params.ts';
+import type { RouteParam, RoutePattern } from '../../types/internal/routes.ts';
+import * as errors from '../errors.ts';
+
+export function exec(
+	match: RegExpMatchArray,
+	params: readonly RouteParam[],
+	matchers: Record<string, ParamMatcher>
+): Record<string, ParamValue> | undefined {
+	const captures = match.slice(1);
+	const result: Record<string, ParamValue> = {};
+	let skipped = 0;
+	for (const [index, param] of params.entries()) {
+		let capture = captures[index - skipped];
+		if (param.rest && param.chained && skipped > 0) {
+			capture = captures
+				.slice(index - skipped, index + 1)
+				.filter(Boolean)
+				.join('/');
+			skipped = 0;
+		}
+		if (capture === undefined) {
+			if (!param.rest) continue;
+			capture = '';
+		}
+		const decoded = decodeURIComponent(capture);
+		if (param.matcher) {
+			const validation = matchers[param.matcher]!['~standard'].validate(decoded);
+			if (validation instanceof Promise) errors.param_matcher_async();
+			if (validation.issues) {
+				if (!param.optional || !param.chained) return undefined;
+				skipped++;
+				continue;
+			}
+			const value: unknown = validation.value;
+			if (
+				typeof value !== 'string' &&
+				typeof value !== 'number' &&
+				typeof value !== 'boolean' &&
+				typeof value !== 'bigint'
+			)
+				errors.param_matcher_result_invalid();
+			result[param.name] = value;
+		} else {
+			result[param.name] = decoded;
+		}
+		const next = params[index + 1];
+		if (next?.optional && !next.rest && captures[index + 1] && param.chained) skipped = 0;
+		if (
+			!next &&
+			!captures[index + 1] &&
+			Object.keys(result).length === captures.filter((value) => value !== undefined).length
+		)
+			skipped = 0;
+	}
+	return skipped ? undefined : result;
+}
+
+export interface RouteMatch<T> {
+	route: T;
+	params: Record<string, ParamValue>;
+}
+
+export function findRoute<T extends RoutePattern>(
+	path: string,
+	routes: readonly T[],
+	matchers: Record<string, ParamMatcher>
+): RouteMatch<T> | null {
+	for (const route of routes) {
+		const match = route.pattern.exec(path);
+		if (!match) continue;
+		const params = exec(match, route.params, matchers);
+		if (params) return { route, params };
+	}
+	return null;
+}

package/src/shared/routing/pattern.ts

@@ -0,0 +1,141 @@
+import type { ParamValue } from '../../types/params.ts';
+import type { RouteParam, RoutePattern } from '../../types/internal/routes.ts';
+import * as errors from '../errors.ts';
+
+export interface RouteToken {
+	text: string;
+	param?: RouteParam;
+}
+
+const parameter = /^(\[)?(\.\.\.)?([\w-]+)(?:=([\w-]+))?(\])?$/;
+const tokens = /\[([ux])\+([^\]]+)\]|\[(\[)?(\.\.\.)?([\w-]+)(?:=([\w-]+))?\]\]?/g;
+
+export function routeSegments(id: string): string[] {
+	return id.split('/').filter((segment) => segment !== '' && !/^\([^)]+\)$/.test(segment));
+}
+
+export function decodeEscape(code: string): string {
+	return String.fromCodePoint(...code.split('-').map((part) => Number.parseInt(part, 16)));
+}
+
+export function encodePathChars(value: string): string {
+	return value.replace(/[%/?#]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+export function invalidParam(id: string): string | undefined {
+	for (const segment of routeSegments(id)) {
+		const pieces = segment.split(/\[(.+?)\](?!\])/);
+		for (let i = 1; i < pieces.length; i += 2) {
+			const content = pieces[i]!;
+			if (!/^[ux]\+/.test(content) && !parameter.test(content)) return content;
+		}
+	}
+	return undefined;
+}
+
+export function segmentTokens(segment: string): RouteToken[] {
+	const output: RouteToken[] = [];
+	let cursor = 0;
+	let literal = '';
+	for (const match of segment.matchAll(tokens)) {
+		literal += segment.slice(cursor, match.index);
+		if (match[1]) {
+			literal += decodeEscape(match[2]!);
+		} else {
+			output.push(
+				{ text: literal },
+				{
+					text: match[0],
+					param: {
+						name: match[5]!,
+						matcher: match[6],
+						optional: !!match[3],
+						rest: !!match[4],
+						chained: !!match[4] && match.index === 0
+					}
+				}
+			);
+			literal = '';
+		}
+		cursor = match.index + match[0].length;
+	}
+	output.push({ text: literal + segment.slice(cursor) });
+	return output;
+}
+
+function literalPattern(text: string): string {
+	return text
+		.normalize()
+		.split(/([%/?#])/)
+		.map((part) => {
+			if (part === '/') return '%2[Ff]';
+			if (part === '?') return '%3[Ff]';
+			if (part === '%') return '%25';
+			if (part === '#') return '%23';
+			return part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+		})
+		.join('');
+}
+
+export function parseRoute(id: string): RoutePattern {
+	const params: RouteParam[] = [];
+	const segments = routeSegments(id);
+	if (!segments.length) return { pattern: /^\/$/, params };
+	const source = segments
+		.map((segment) => {
+			const pieces = segmentTokens(segment);
+			const dynamic = pieces.filter((piece) => piece.param);
+			const whole = dynamic.length === 1 && dynamic[0]!.text === segment;
+			if (whole && (dynamic[0]!.param!.rest || dynamic[0]!.param!.optional)) {
+				const param = { ...dynamic[0]!.param!, chained: true };
+				params.push(param);
+				return param.rest ? '(?:/([^]*))?' : '(?:/([^/]+))?';
+			}
+			return (
+				'/' +
+				pieces
+					.map(({ text, param }) => {
+						if (!param) return literalPattern(text);
+						params.push(param);
+						return param.rest ? '([^]*?)' : param.optional ? '([^/]*)?' : '([^/]+?)';
+					})
+					.join('')
+			);
+		})
+		.join('');
+	return { pattern: new RegExp(`^${source}/?$`), params };
+}
+
+export function resolveRoute(id: string, params: Record<string, ParamValue | undefined>): string {
+	const segments = routeSegments(id)
+		.map((segment) =>
+			segment.replace(
+				tokens,
+				(
+					_all,
+					kind: string | undefined,
+					code: string,
+					optional: string | undefined,
+					rest: string | undefined,
+					name: string
+				) => {
+					if (kind) return encodePathChars(decodeEscape(code));
+					const value = params[name];
+					if (value === undefined || value === '') {
+						if (optional || (rest && value !== undefined)) return '';
+						errors.route_param_missing({ id, name });
+					}
+					if (typeof value === 'string') {
+						if (value.startsWith('/') || value.endsWith('/'))
+							errors.route_param_slash({ id, name });
+						return value;
+					}
+					if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint')
+						return String(value);
+					return errors.route_param_value_invalid({ id, name });
+				}
+			)
+		)
+		.filter(Boolean);
+	return '/' + segments.join('/') + (id !== '/' && id.endsWith('/') ? '/' : '');
+}

package/src/shared/routing/sort.ts

@@ -0,0 +1,75 @@
+import { routeSegments } from './pattern.ts';
+
+interface SortRoute {
+	id: string;
+}
+interface Part {
+	text: string;
+	kind: 'static' | 'required' | 'optional' | 'rest';
+	matched: boolean;
+}
+
+function staticOrder(a: string, b: string): number {
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		if (a[i] === b[i]) continue;
+		if (a[i] === undefined) return 1;
+		if (b[i] === undefined) return -1;
+		return a[i]! < b[i]! ? -1 : 1;
+	}
+	return 0;
+}
+
+export function sortRoutes<T extends SortRoute>(routes: T[]): T[] {
+	const parsed = new Map<string, Part[][]>();
+	const parts = (id: string): Part[][] => {
+		let value = parsed.get(id);
+		if (!value) {
+			value = routeSegments(id.replace(/\[\[[^\]]+\]\](?!(?:\/\([^/]+\))*$)/g, '')).map((segment) =>
+				segment.split(/(\[\[.*?\]\]|\[.*?\])/).map((text, index) => ({
+					text,
+					kind:
+						index % 2 === 0
+							? 'static'
+							: text.startsWith('[...')
+								? 'rest'
+								: text.startsWith('[[')
+									? 'optional'
+									: 'required',
+					matched: index % 2 === 1 && text.includes('=')
+				}))
+			);
+			parsed.set(id, value);
+		}
+		return value;
+	};
+	return routes.sort((a, b) => {
+		const left = parts(a.id);
+		const right = parts(b.id);
+		for (let segment = 0; segment < Math.max(left.length, right.length); segment++) {
+			const l = left[segment];
+			const r = right[segment];
+			if (!l || !r) return l ? 1 : -1;
+			for (let piece = 0; piece < Math.max(l.length, r.length); piece++) {
+				const x = l[piece];
+				const y = r[piece];
+				if (!x || !y) return x ? 1 : -1;
+				if (x.kind === 'static' && y.kind === 'static') {
+					const order = staticOrder(x.text, y.text);
+					if (order) return order;
+					continue;
+				}
+				const afterX = l[piece + 1]?.text || left[segment + 1]?.[0]?.text;
+				const afterY = r[piece + 1]?.text || right[segment + 1]?.[0]?.text;
+				if (x.kind === 'rest' && y.kind === 'rest') {
+					if (afterX && afterY) continue;
+					if (!!afterX !== !!afterY) return afterX ? -1 : 1;
+				}
+				if (x.kind === 'rest') return afterX && !afterY ? -1 : 1;
+				if (y.kind === 'rest') return afterY && !afterX ? 1 : -1;
+				if (x.matched !== y.matched) return x.matched ? -1 : 1;
+				if (x.kind !== y.kind) return x.kind === 'required' ? -1 : 1;
+			}
+		}
+		return a.id === b.id ? 0 : a.id < b.id ? 1 : -1;
+	});
+}

package/src/shared/serialization.ts

@@ -0,0 +1,21 @@
+import { parse, stringify } from 'devalue';
+import type { Transport } from '../types/hooks.ts';
+
+export type Encoders = Record<string, (value: any) => any>;
+export type Decoders = Record<string, (value: any) => any>;
+
+export function encoders(transport: Transport): Encoders {
+	return Object.fromEntries(Object.entries(transport).map(([name, codec]) => [name, codec.encode]));
+}
+
+export function decoders(transport: Transport): Decoders {
+	return Object.fromEntries(Object.entries(transport).map(([name, codec]) => [name, codec.decode]));
+}
+
+export function serialize(value: unknown, transport: Transport = {}): string {
+	return stringify(value, encoders(transport));
+}
+
+export function deserialize(value: string, transport: Transport = {}): any {
+	return parse(value, decoders(transport));
+}

package/src/shared/url.ts

@@ -0,0 +1,86 @@
+import { DEV } from 'esm-env';
+import type { TrailingSlash } from '../types/internal/data.ts';
+import { url_hash_unavailable } from './errors.ts';
+
+export const SCHEME = /^[a-z][a-z\d+\-.]+:/i;
+
+export function decodePathname(path: string): string {
+	return path
+		.split('%25')
+		.map((part) => decodeURI(part))
+		.join('%25');
+}
+
+export function normalizePath(path: string, slash: TrailingSlash): string {
+	if (path === '/' || slash === 'ignore') return path;
+	if (slash === 'always') return path.endsWith('/') ? path : `${path}/`;
+	return path.endsWith('/') ? path.slice(0, -1) : path;
+}
+
+export function relativePathname(from: string, to: string): string {
+	const segment = to.replace(/\/$/, '').split('/').at(-1);
+	return from.endsWith('/') ? `../${segment}` : `./${segment}/`;
+}
+
+export function stripHash(url: { href: string }): string {
+	return url.href.split('#')[0]!;
+}
+
+const inspectCustom = Symbol.for('nodejs.util.inspect.custom');
+
+function inspectAs(
+	value: () => object
+): (depth: number, options: object, inspect: (value: object, options: object) => string) => string {
+	return (_depth, options, inspect) => inspect(value(), options);
+}
+
+export function makeTrackable(
+	url: URL,
+	onUrl: () => void,
+	onSearch: (name: string) => void,
+	allowHash = false
+): URL {
+	const copy = new URL(url);
+	Object.defineProperty(copy.searchParams, inspectCustom, {
+		configurable: true,
+		value: inspectAs(() => new URL(url.href).searchParams)
+	});
+	const search = new Proxy(copy.searchParams, {
+		get(target, key) {
+			if (key === 'get' || key === 'getAll' || key === 'has') {
+				return (name: string, value?: string) => {
+					onSearch(name);
+					return key === 'has' ? target.has(name, value) : target[key](name);
+				};
+			}
+			onUrl();
+			const value: unknown = Reflect.get(target, key, target);
+			return typeof value === 'function' ? value.bind(target) : value;
+		}
+	});
+	Object.defineProperty(copy, 'searchParams', {
+		enumerable: true,
+		configurable: true,
+		value: search
+	});
+	const properties: Array<keyof URL> = ['href', 'pathname', 'search', 'toJSON', 'toString'];
+	if (allowHash) properties.push('hash');
+	for (const property of properties) {
+		Object.defineProperty(copy, property, {
+			enumerable: true,
+			configurable: true,
+			get() {
+				onUrl();
+				const value = url[property];
+				return typeof value === 'function' ? value.bind(url) : value;
+			}
+		});
+	}
+	if (DEV && !allowHash)
+		Object.defineProperty(copy, 'hash', { configurable: true, get: url_hash_unavailable });
+	Object.defineProperty(copy, inspectCustom, {
+		configurable: true,
+		value: inspectAs(() => new URL(url.href))
+	});
+	return copy;
+}

package/src/shared/warnings.ts

@@ -0,0 +1,25 @@
+import { DEV } from 'esm-env';
+import { warnCode, warnDiagnostic } from './diagnostics.ts';
+
+interface SchemeWarning {
+	route: string;
+	dependency: string;
+	scheme: string;
+}
+
+export function form_fields_enumerated(): void {
+	if (DEV)
+		warnDiagnostic(
+			'form_fields_enumerated',
+			'The properties of `form.fields` are virtual, so operators like `in` and `Object.keys` are meaningless. If you need the current value of a form field, use `form.fields.x.value()`'
+		);
+	else warnCode('form_fields_enumerated');
+}
+export function depends_special_scheme(values: SchemeWarning): void {
+	if (DEV)
+		warnDiagnostic(
+			'depends_special_scheme',
+			`\`${values.route}\`: Calling \`depends('${values.dependency}')\` will throw an error in Firefox because \`${values.scheme}\` is a special URI scheme`
+		);
+	else warnCode('depends_special_scheme');
+}