@vigla/kit 0.0.0-stage → 0.1.0

package/src/shared/errors.ts

@@ -0,0 +1,290 @@
+import { BROWSER, DEV } from 'esm-env';
+import {
+	documentationLink,
+	runtime,
+	throwCode,
+	throwDiagnostic,
+	verbose,
+	type Diagnostics
+} from './diagnostics.ts';
+import { identity } from './identity.ts';
+
+interface StatusMessage {
+	status: string;
+}
+interface LocationMessage {
+	location: string;
+}
+interface KeyMessage {
+	key: string;
+}
+interface NameMessage {
+	name: string;
+}
+interface TypeMessage {
+	type: string;
+}
+interface ExportMessage extends KeyMessage {
+	exports: string;
+	file?: string;
+}
+interface ExportLocation extends KeyMessage {
+	locations: string;
+	file?: string;
+}
+interface LoadMessage extends LocationMessage, TypeMessage {}
+interface DuplicateField extends NameMessage {
+	count: string;
+}
+interface RouteMessage {
+	id: string;
+}
+interface RouteParam extends RouteMessage, NameMessage {}
+interface HashOptions {
+	source: string;
+	options: string;
+}
+
+export function invalid_error_status(values: StatusMessage, d: Diagnostics = runtime): never {
+	if (DEV || (!BROWSER && verbose))
+		d.raise(
+			'invalid_error_status',
+			`HTTP error status codes must be between 400 and 599 — ${values.status} is invalid`,
+			invalid_error_status
+		);
+	d.raiseCode('invalid_error_status');
+}
+export function invalid_redirect_status(values: StatusMessage, d: Diagnostics = runtime): never {
+	if (DEV || (!BROWSER && verbose))
+		d.raise(
+			'invalid_redirect_status',
+			`Redirect status codes must be between 300 and 308 — ${values.status} is invalid`,
+			invalid_redirect_status
+		);
+	d.raiseCode('invalid_redirect_status');
+}
+export function redirect_external_not_allowed(values: LocationMessage, d: Diagnostics): never {
+	if (DEV || (!BROWSER && verbose))
+		d.raise(
+			'redirect_external_not_allowed',
+			`Cannot redirect to external URL \`${values.location}\`. To redirect to an external URL, pass \`{ external: true }\` or an allowlist of permitted origins as the third argument to \`redirect\``,
+			redirect_external_not_allowed
+		);
+	d.raiseCode('redirect_external_not_allowed');
+}
+export function redirect_external_javascript(values: LocationMessage, d: Diagnostics): never {
+	if (DEV || (!BROWSER && verbose))
+		d.raise(
+			'redirect_external_javascript',
+			`Cannot redirect to \`${values.location}\` with \`{ external: true }\`. The \`javascript:\` and \`data:\` protocols must be explicitly listed in the \`external\` allowlist`,
+			redirect_external_javascript
+		);
+	d.raiseCode('redirect_external_javascript');
+}
+export function redirect_external_not_in_allowlist(values: LocationMessage, d: Diagnostics): never {
+	if (DEV || (!BROWSER && verbose))
+		d.raise(
+			'redirect_external_not_in_allowlist',
+			`Cannot redirect to \`${values.location}\`: URL origin is not included in the \`external\` allowlist`,
+			redirect_external_not_in_allowlist
+		);
+	d.raiseCode('redirect_external_not_in_allowlist');
+}
+export function redirect_external_option_invalid(d: Diagnostics): never {
+	if (DEV || (!BROWSER && verbose))
+		d.raise(
+			'redirect_external_option_invalid',
+			'`redirect` `options.external` must be `true` or an array of allowed origins',
+			redirect_external_option_invalid
+		);
+	d.raiseCode('redirect_external_option_invalid');
+}
+export function service_worker_module_outside_worker(): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'service_worker_module_outside_worker',
+			'The `$app/service-worker` module can only be imported into a service worker',
+			service_worker_module_outside_worker
+		);
+	throwCode('service_worker_module_outside_worker');
+}
+export function match_in_service_worker(): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'match_in_service_worker',
+			`Cannot use \`match(...)\` inside a service worker, as it depends on the ${identity.product} client instance`,
+			match_in_service_worker
+		);
+	throwCode('match_in_service_worker');
+}
+export function resolve_params_missing(values: RouteMessage): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'resolve_params_missing',
+			`Missing params for dynamic route ID \`${values.id}\``,
+			resolve_params_missing
+		);
+	throwCode('resolve_params_missing');
+}
+export function url_hash_unavailable(): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'url_hash_unavailable',
+			'Cannot access `event.url.hash`. Consider using `page.url.hash` inside a component instead',
+			url_hash_unavailable
+		);
+	throwCode('url_hash_unavailable');
+}
+export function form_field_unbound(values: NameMessage): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'form_field_unbound',
+			`Form contained a field that wasn't created with \`form.fields.as(...)\`: \`${values.name}\``,
+			form_field_unbound
+		);
+	throwCode('form_field_unbound');
+}
+export function form_field_duplicate(values: DuplicateField): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'form_field_duplicate',
+			`Form cannot contain duplicated keys — \`${values.name}\` has ${values.count} values`,
+			form_field_duplicate
+		);
+	throwCode('form_field_duplicate');
+}
+export function form_field_invalid_name(values: NameMessage): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'form_field_invalid_name',
+			`Invalid field name \`${values.name}\`: field names are written in JS object notation, so keys that would need quoting are not supported.${documentationLink('formFields')}`,
+			form_field_invalid_name
+		);
+	throwCode('form_field_invalid_name');
+}
+export function form_field_forbidden_key(values: KeyMessage): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'form_field_forbidden_key',
+			`Invalid key \`${values.key}\`: This key is not allowed to prevent prototype pollution.`,
+			form_field_forbidden_key
+		);
+	throwCode('form_field_forbidden_key');
+}
+export function form_field_array_conflict(values: KeyMessage): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'form_field_array_conflict',
+			`Invalid array key \`${values.key}\``,
+			form_field_array_conflict
+		);
+	throwCode('form_field_array_conflict');
+}
+export function remote_argument_unsupported(values: TypeMessage): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'remote_argument_unsupported',
+			`${values.type} are not valid remote function arguments`,
+			remote_argument_unsupported
+		);
+	throwCode('remote_argument_unsupported');
+}
+export function form_input_missing_value(values: TypeMessage): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'form_input_missing_value',
+			`${values.type} inputs must have a value`,
+			form_input_missing_value
+		);
+	throwCode('form_input_missing_value');
+}
+export function load_invalid_response(values: LoadMessage): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'load_invalid_response',
+			`a \`load\` function ${values.location} returned ${values.type}, but must return a plain object at the top level (i.e. \`return {...}\`)`,
+			load_invalid_response
+		);
+	throwCode('load_invalid_response');
+}
+export function param_matcher_async(): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'param_matcher_async',
+			'Async param matchers are not supported',
+			param_matcher_async
+		);
+	throwCode('param_matcher_async');
+}
+export function param_matcher_result_invalid(): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'param_matcher_result_invalid',
+			'Param matcher must return a string, number, boolean, or bigint',
+			param_matcher_result_invalid
+		);
+	throwCode('param_matcher_result_invalid');
+}
+export function param_definition_invalid(d: Diagnostics = runtime): never {
+	if (DEV || (!BROWSER && verbose))
+		d.raise('param_definition_invalid', 'Invalid param definition', param_definition_invalid);
+	d.raiseCode('param_definition_invalid');
+}
+export function route_param_missing(values: RouteParam): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'route_param_missing',
+			`Missing parameter \`${values.name}\` in route \`${values.id}\``,
+			route_param_missing
+		);
+	throwCode('route_param_missing');
+}
+export function route_param_slash(values: RouteParam): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'route_param_slash',
+			`Parameter \`${values.name}\` in route \`${values.id}\` cannot start or end with a slash — this would cause an invalid route like \`foo/bar\``,
+			route_param_slash
+		);
+	throwCode('route_param_slash');
+}
+export function route_param_value_invalid(values: RouteParam): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'route_param_value_invalid',
+			`Parameter \`${values.name}\` in route \`${values.id}\` must be a string, number, boolean, or bigint`,
+			route_param_value_invalid
+		);
+	throwCode('route_param_value_invalid');
+}
+export function invalid_export(values: ExportMessage, d: Diagnostics = runtime): never {
+	if (DEV || (!BROWSER && verbose)) {
+		const source = values.file === undefined ? '' : ` in \`${values.file}\``;
+		d.raise(
+			'invalid_export',
+			`Invalid export \`${values.key}\`${source} (valid exports are ${values.exports}, or anything with a \`'_'\` prefix)`,
+			invalid_export
+		);
+	}
+	d.raiseCode('invalid_export');
+}
+export function invalid_export_location(values: ExportLocation): never {
+	if (DEV || (!BROWSER && verbose)) {
+		const source = values.file === undefined ? '' : ` in \`${values.file}\``;
+		throwDiagnostic(
+			'invalid_export_location',
+			`Invalid export \`${values.key}\`${source} (\`${values.key}\` is a valid export in ${values.locations})`,
+			invalid_export_location
+		);
+	}
+	throwCode('invalid_export_location');
+}
+export function router_hash_page_options(values: HashOptions): never {
+	if (DEV || (!BROWSER && verbose))
+		throwDiagnostic(
+			'router_hash_page_options',
+			`Page options are ignored when \`router.type === 'hash'\` (\`${values.source}\` has ${values.options})`,
+			router_hash_page_options
+		);
+	throwCode('router_hash_page_options');
+}

package/src/shared/escape.ts

@@ -0,0 +1,27 @@
+export function escapeHtml(value: string, attribute = false): string {
+	return value.replace(attribute ? /[&"]|\p{Surrogate}/gu : /[&<]|\p{Surrogate}/gu, (character) => {
+		if (character === '&') return '&amp;';
+		if (character === '"') return '&quot;';
+		if (character === '<') return '&lt;';
+		return `&#${character.charCodeAt(0)};`;
+	});
+}
+
+export function escapeJson(value: unknown): string {
+	return JSON.stringify(value).replace(
+		/[<\u2028\u2029]/g,
+		(character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, '0')}`
+	);
+}
+
+export interface Interpolation {
+	placeholder: string;
+	replacement: string;
+}
+
+export function escapeInterpolation(value: string, replacements: Interpolation[] = []): string {
+	let escaped = JSON.stringify(value).slice(1, -1).replace(/[`$]/g, '\\$&');
+	for (const { placeholder, replacement } of replacements)
+		escaped = escaped.replaceAll(placeholder, replacement);
+	return escaped;
+}

package/src/shared/form-data.ts

@@ -0,0 +1,257 @@
+import { parse, stringify } from 'devalue';
+import type { BinaryFormMeta } from '../types/internal/remote.ts';
+import { HttpError } from './outcomes.ts';
+import { coerceFormValue, parseFormKey, setNestedValue } from './form-fields.ts';
+import * as errors from './errors.ts';
+import { identity } from './identity.ts';
+
+export type { BinaryFormMeta } from '../types/internal/remote.ts';
+
+export interface DecodedForm {
+	data: Record<string, any>;
+	meta: BinaryFormMeta;
+	formData: FormData | null;
+}
+export const BINARY_FORM_CONTENT_TYPE = `application/x-${identity.name}-formdata`;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export function convertFormData(formId: string, data: FormData): Record<string, any> {
+	const result: Record<string, any> = {};
+	for (const key of new Set(data.keys())) {
+		const field = parseFormKey(formId, key);
+		const entries = data
+			.getAll(key)
+			.filter((entry) => typeof entry === 'string' || entry.name || entry.size);
+		if (!entries.length && !field.isArray) continue;
+		if (entries.length > 1 && !field.isArray) {
+			errors.form_field_duplicate({ name: field.name, count: String(entries.length) });
+		}
+		setNestedValue(
+			result,
+			field,
+			coerceFormValue(field.type, field.isArray ? entries : entries[0])
+		);
+	}
+	return result;
+}
+
+export function serializeBinaryForm(
+	data: Record<string, any>,
+	meta: BinaryFormMeta
+): { blob: Blob } {
+	const files: Array<{ file: File; index: number }> = [];
+	const header = encoder.encode(
+		stringify([data, meta], {
+			File(value: unknown) {
+				if (!(value instanceof File)) return;
+				const index = files.length;
+				files.push({ file: value, index });
+				return [value.name, value.type, value.size, value.lastModified, index];
+			}
+		})
+	);
+	files.sort((a, b) => a.file.size - b.file.size);
+	const offsets: number[] = [];
+	let position = 0;
+	for (const { file, index } of files) {
+		offsets[index] = position;
+		position += file.size;
+	}
+	const table = files.length ? JSON.stringify(offsets) : '';
+	const prefix = new Uint8Array(7);
+	const view = new DataView(prefix.buffer);
+	view.setUint32(1, header.byteLength, true);
+	view.setUint16(5, table.length, true);
+	return { blob: new Blob([prefix, header, table, ...files.map(({ file }) => file)]) };
+}
+
+function invalid(detail: string): never {
+	const error = new HttpError({ status: 400, message: 'Bad Request' });
+	Object.defineProperty(error, 'message', {
+		value: `Could not deserialize binary form: ${detail}`
+	});
+	throw error;
+}
+
+class BodyRanges {
+	readonly #reader: ReadableStreamDefaultReader<Uint8Array>;
+	readonly #chunks: Array<Promise<Uint8Array | undefined>> = [];
+
+	constructor(body: ReadableStream<Uint8Array>) {
+		this.#reader = body.getReader();
+	}
+
+	chunk(index: number): Promise<Uint8Array | undefined> {
+		while (this.#chunks.length <= index) {
+			const previous = this.#chunks.at(-1) ?? Promise.resolve(undefined);
+			this.#chunks.push(previous.then(() => this.#reader.read()).then((result) => result.value));
+		}
+		return this.#chunks[index]!;
+	}
+
+	async *range(offset: number, length: number): AsyncGenerator<Uint8Array> {
+		let start = 0;
+		for (let index = 0; ; index++) {
+			const chunk = await this.chunk(index);
+			if (!chunk) return;
+			const end = start + chunk.byteLength;
+			if (end > offset) {
+				yield chunk.subarray(
+					Math.max(offset - start, 0),
+					Math.min(chunk.byteLength, offset + length - start)
+				);
+				if (offset + length <= end) return;
+			}
+			start = end;
+		}
+	}
+
+	async bytes(offset: number, length: number): Promise<Uint8Array> {
+		const parts: Uint8Array[] = [];
+		let size = 0;
+		for await (const part of this.range(offset, length)) {
+			parts.push(part);
+			size += part.byteLength;
+		}
+		if (size !== length) invalid(offset === 0 ? 'too short' : 'data too short');
+		if (parts.length === 1) return parts[0]!;
+		const bytes = new Uint8Array(size);
+		let cursor = 0;
+		for (const part of parts) {
+			bytes.set(part, cursor);
+			cursor += part.byteLength;
+		}
+		return bytes;
+	}
+
+	async drain(): Promise<void> {
+		while (await this.chunk(this.#chunks.length)) {}
+	}
+}
+
+class DeferredFile implements File {
+	readonly webkitRelativePath = '';
+	readonly [Symbol.toStringTag] = 'File';
+	readonly #body: BodyRanges;
+	readonly #offset: number;
+	#buffer?: ArrayBuffer;
+	readonly name: string;
+	readonly type: string;
+	readonly size: number;
+	readonly lastModified: number;
+
+	constructor(
+		name: string,
+		type: string,
+		size: number,
+		lastModified: number,
+		body: BodyRanges,
+		offset: number
+	) {
+		this.name = name;
+		this.type = type;
+		this.size = size;
+		this.lastModified = lastModified;
+		this.#body = body;
+		this.#offset = offset;
+	}
+
+	arrayBuffer = async (): Promise<ArrayBuffer> => {
+		return (this.#buffer ??= await new Response(this.stream()).arrayBuffer());
+	};
+	bytes = async (): Promise<Uint8Array<ArrayBuffer>> => new Uint8Array(await this.arrayBuffer());
+	text = async (): Promise<string> => decoder.decode(await this.arrayBuffer());
+	slice = (start = 0, end = this.size, type = this.type): Blob => {
+		const clamp = (offset: number) =>
+			Math.min(this.size, Math.max(0, offset < 0 ? this.size + offset : offset));
+		const from = clamp(start);
+		return new DeferredFile(
+			this.name,
+			type,
+			Math.max(0, clamp(end) - from),
+			this.lastModified,
+			this.#body,
+			this.#offset + from
+		);
+	};
+	stream = (): ReadableStream<Uint8Array<ArrayBuffer>> => {
+		const range = this.#body.range(this.#offset, this.size);
+		let read = 0;
+		return new ReadableStream({
+			pull: async (controller) => {
+				const next = await range.next();
+				if (next.done) {
+					if (read < this.size) throw new Error('incomplete file data');
+					controller.close();
+				} else {
+					read += next.value.byteLength;
+					controller.enqueue(next.value as Uint8Array<ArrayBuffer>);
+				}
+			},
+			cancel: async () => {
+				await range.return(undefined);
+			}
+		});
+	};
+}
+
+export async function deserializeBinaryForm(
+	request: Request,
+	formId: string
+): Promise<DecodedForm> {
+	if (request.headers.get('content-type') !== BINARY_FORM_CONTENT_TYPE) {
+		const formData = await request.formData();
+		return { data: convertFormData(formId, formData), meta: {}, formData };
+	}
+	if (!request.body) invalid('no body');
+	const body = new BodyRanges(request.body);
+	const prefix = await body.bytes(0, 7);
+	if (prefix[0] !== 0) invalid(`got version ${prefix[0]}, expected version 0`);
+	const view = new DataView(prefix.buffer, prefix.byteOffset, prefix.byteLength);
+	const length = view.getUint32(1, true);
+	const tableLength = view.getUint16(5, true);
+	const header = decoder.decode(await body.bytes(7, length));
+	const offsets: Array<number | undefined> = tableLength
+		? JSON.parse(decoder.decode(await body.bytes(7 + length, tableLength)))
+		: [];
+	if (
+		!Array.isArray(offsets) ||
+		offsets.some((offset) => !Number.isInteger(offset) || offset! < 0)
+	) {
+		invalid('invalid file offset table');
+	}
+	const start = 7 + length + tableLength;
+	const spans: Array<{ offset: number; size: number }> = [];
+	const [data, meta] = parse(header, {
+		File(metadata: unknown) {
+			if (!Array.isArray(metadata)) invalid('invalid file metadata');
+			const [name, type, size, modified, index] = metadata;
+			if (
+				typeof name !== 'string' ||
+				typeof type !== 'string' ||
+				!Number.isSafeInteger(size) ||
+				size < 0 ||
+				!Number.isSafeInteger(modified) ||
+				!Number.isSafeInteger(index) ||
+				index < 0
+			)
+				invalid('invalid file metadata');
+			const offset = offsets[index];
+			if (offset === undefined) invalid('duplicate file offset table index');
+			offsets[index] = undefined;
+			spans.push({ offset, size });
+			return new Proxy(new DeferredFile(name, type, size, modified, body, start + offset), {
+				getPrototypeOf: () => File.prototype
+			});
+		}
+	});
+	spans.sort((a, b) => a.offset - b.offset || a.size - b.size);
+	for (let index = 1; index < spans.length; index++) {
+		const end = spans[index - 1]!.offset + spans[index - 1]!.size;
+		if (end < spans[index]!.offset) invalid('gaps in file data');
+		if (end > spans[index]!.offset) invalid('overlapping file data');
+	}
+	void body.drain().catch(() => {});
+	return { data, meta, formData: null };
+}