@vigla/kit 0.0.0-stage → 0.1.1

package/src/shared/form-fields.ts

@@ -0,0 +1,344 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { DEV } from 'esm-env';
+import type { OpenFields, RemoteFormIssue } from '../types/fields.ts';
+import type { InternalFormIssue } from '../types/internal/remote.ts';
+import { throwDiagnostic, warnDiagnostic } from './diagnostics.ts';
+import * as errors from './errors.ts';
+
+export type { InternalFormIssue } from '../types/internal/remote.ts';
+
+export interface FormKey {
+	name: string;
+	type: 'number' | 'boolean' | null;
+	isArray: boolean;
+}
+export const DELETE_KEY = {};
+
+export function splitPath(path: string): string[] {
+	if (!/^[a-zA-Z_$]\w*(\.[a-zA-Z_$]\w*|\[\d+\])*$/.test(path)) {
+		errors.form_field_invalid_name({ name: path });
+	}
+	return path.split(/\.|\[|\]/).filter(Boolean);
+}
+
+export function parseFormKey(formId: string, key: string): FormKey {
+	const suffix = `/${formId}`;
+	let name = key;
+	let coordinate = '';
+	if (name.startsWith('i:') && (name.endsWith(`${suffix}.x`) || name.endsWith(`${suffix}.y`))) {
+		coordinate = name.slice(-1);
+		name = name.slice(0, -2);
+	}
+	if (!name.endsWith(suffix)) errors.form_field_unbound({ name });
+	name = name.slice(0, -suffix.length);
+	let type: FormKey['type'] = null;
+	if (/^[nbi]:/.test(name)) {
+		type = name.startsWith('b:') ? 'boolean' : 'number';
+		name = name.slice(2);
+	}
+	const isArray = name.endsWith('[]');
+	if (isArray) name = name.slice(0, -2);
+	return { name: coordinate ? `${name}.${coordinate}` : name, type, isArray };
+}
+
+export function coerceFormValue(type: FormKey['type'], value: any): any {
+	if (Array.isArray(value)) return value.map((entry) => coerceFormValue(type, entry));
+	if (type === 'number') return value === '' ? undefined : parseFloat(value);
+	if (type === 'boolean') return value === 'on';
+	return value;
+}
+
+export function deepSet(
+	object: Record<string, any>,
+	path: Array<string | number>,
+	value: any
+): void {
+	let current = object;
+	for (let index = 0; index < path.length; index++) {
+		const key = path[index]!;
+		if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+			errors.form_field_forbidden_key({ key });
+		}
+		if (index === path.length - 1) {
+			if (value === DELETE_KEY) delete current[key];
+			else current[key] = value;
+			return;
+		}
+		const next = String(path[index + 1]);
+		const isArray = /^\d+$/.test(next);
+		const inner = Object.hasOwn(current, key) ? current[key] : undefined;
+		if (inner != null && Array.isArray(inner) !== isArray)
+			errors.form_field_array_conflict({ key: next });
+		if (inner == null) {
+			if (value === DELETE_KEY) return;
+			current[key] = isArray ? [] : {};
+		}
+		current = current[key];
+	}
+}
+
+export function setNestedValue(object: Record<string, any>, field: FormKey, value: any): void {
+	deepSet(object, splitPath(field.name), value);
+}
+
+export function deepGet(object: Record<string, any>, path: Array<string | number>): any {
+	let current = object;
+	for (const key of path) {
+		if (current === null || typeof current !== 'object' || !Object.hasOwn(current, key))
+			return undefined;
+		current = current[key];
+	}
+	return current;
+}
+
+export function fillMissing(target: Record<string, any>, source: Record<string, any>): void {
+	for (const key of Object.keys(source)) {
+		const value = source[key];
+		if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;
+		const current = Object.hasOwn(target, key) ? target[key] : undefined;
+		if (current === undefined) target[key] = value;
+		else if (
+			value !== null &&
+			typeof value === 'object' &&
+			current !== null &&
+			typeof current === 'object' &&
+			!(typeof File !== 'undefined' && value instanceof File)
+		)
+			fillMissing(current, value);
+	}
+}
+
+export function buildPath(path: Array<string | number>): string {
+	return path.reduce<string>(
+		(name, key) =>
+			typeof key === 'number' ? `${name}[${key}]` : `${name}${name ? '.' : ''}${key}`,
+		''
+	);
+}
+
+export function normalizeIssue(issue: StandardSchemaV1.Issue, server = false): InternalFormIssue {
+	const path = (issue.path ?? []).map(
+		(segment) => (typeof segment === 'object' ? segment.key : segment) as string | number
+	);
+	return { name: buildPath(path), path, message: issue.message, server };
+}
+
+export function flattenIssues(issues: InternalFormIssue[]): Record<string, InternalFormIssue[]> {
+	const result: Record<string, InternalFormIssue[]> = Object.create(null);
+	for (const issue of issues) {
+		(result.$ ??= []).push(issue);
+		for (let length = 1; length <= issue.path.length; length++) {
+			(result[buildPath(issue.path.slice(0, length))] ??= []).push(issue);
+		}
+	}
+	return result;
+}
+
+export interface FieldContext {
+	id: string;
+	get(): Record<string, any>;
+	set(path: (string | number)[], value: any): void;
+	issues(path?: (string | number)[], all?: boolean): Record<string, InternalFormIssue[]>;
+	touched(): Record<string, boolean>;
+	dirty(): Record<string, boolean>;
+}
+
+type Path = (string | number)[];
+
+function clone(value: any): any {
+	if (value === null || typeof value !== 'object') return value;
+	if (value instanceof Date) return new Date(value.getTime());
+	if (typeof File !== 'undefined' && value instanceof File) return value;
+	if (Array.isArray(value)) return value.map(clone);
+	const result: Record<string, any> = {};
+	for (const key of Object.keys(value)) result[key] = clone(value[key]);
+	return result;
+}
+
+function publicIssue(issue: InternalFormIssue): RemoteFormIssue {
+	return { path: issue.path, message: issue.message };
+}
+
+function hasChange(changes: Record<string, boolean>, key: string): boolean {
+	if (Object.hasOwn(changes, key)) return true;
+	for (const candidate of Object.keys(changes)) {
+		if (key === '') return true;
+		if (
+			candidate.startsWith(key) &&
+			(candidate[key.length] === '.' || candidate[key.length] === '[')
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function missingValue(type: string): never {
+	throwDiagnostic('form_input_missing_value', `${type} inputs must have a value`, missingValue);
+}
+
+function inputAttributes(
+	context: FieldContext,
+	path: Path,
+	type: string,
+	option?: any,
+	checked?: boolean
+): Record<string, any> {
+	const key = buildPath(path);
+	const multiple =
+		type === 'file multiple' ||
+		type === 'select multiple' ||
+		(type === 'checkbox' && typeof option === 'string');
+	let prefix = '';
+	if (type === 'number' || type === 'range') prefix = 'n:';
+	else if (type === 'image') prefix = 'i:';
+	else if (type === 'checkbox' && !multiple) prefix = 'b:';
+	else if (type === 'hidden' || type === 'submit') {
+		if (typeof option === 'number') prefix = 'n:';
+		else if (typeof option === 'boolean') prefix = 'b:';
+	}
+
+	const attributes: Record<string, any> = {
+		name: `${prefix}${key}${multiple ? '[]' : ''}/${context.id}`,
+		get 'aria-invalid'() {
+			return key in context.issues() ? 'true' : undefined;
+		}
+	};
+	if (type !== 'text' && type !== 'select' && type !== 'select multiple') {
+		attributes.type = type === 'file multiple' ? 'file' : type;
+	}
+	const read = (fallback?: any): any => {
+		const value = deepGet(context.get(), path);
+		if (value != null) return value;
+		return fallback !== undefined && Object.hasOwn(context.dirty(), key) ? undefined : fallback;
+	};
+
+	if (type === 'hidden' || type === 'submit') {
+		if (DEV && option == null) missingValue(`\`${type}\``);
+		attributes.value = typeof option === 'boolean' ? (option ? 'on' : 'off') : option;
+		return attributes;
+	}
+	if (type === 'select' || type === 'select multiple') {
+		attributes.multiple = multiple;
+		Object.defineProperty(attributes, 'value', {
+			enumerable: true,
+			get() {
+				const value = read(option);
+				return Array.isArray(value) ? [...value] : value;
+			}
+		});
+		return attributes;
+	}
+	if (type === 'checkbox' || type === 'radio') {
+		const hasOption = type === 'radio' || multiple;
+		if (DEV && hasOption && !option) missingValue(type === 'radio' ? 'Radio' : 'Checkbox array');
+		if (hasOption) attributes.value = option ?? 'on';
+		else checked = option;
+		attributes.defaultChecked = checked;
+		Object.defineProperty(attributes, 'checked', {
+			enumerable: true,
+			get() {
+				const value = read();
+				if (value == null) return read(checked);
+				if (type === 'radio') return value === option;
+				if (multiple) return value.includes(option);
+				return value;
+			}
+		});
+		return attributes;
+	}
+	if (type === 'file' || type === 'file multiple') {
+		attributes.multiple = multiple;
+		Object.defineProperty(attributes, 'files', {
+			enumerable: true,
+			get() {
+				const value = read();
+				const files = typeof File !== 'undefined' && value instanceof File ? [value] : value;
+				if (
+					typeof File === 'undefined' ||
+					!Array.isArray(files) ||
+					!files.every((file) => file instanceof File)
+				)
+					return null;
+				if (typeof DataTransfer === 'undefined')
+					return Object.assign({ length: files.length }, files);
+				const transfer = new DataTransfer();
+				for (const file of files) transfer.items.add(file);
+				return transfer.files;
+			}
+		});
+		return attributes;
+	}
+	if (type === 'image') return attributes;
+	attributes.defaultValue = option;
+	Object.defineProperty(attributes, 'value', {
+		enumerable: true,
+		get: () => String(read(option) ?? '')
+	});
+	return attributes;
+}
+
+function method(context: FieldContext, path: Path, name: string): Function | undefined {
+	switch (name) {
+		case 'set':
+			return (value: any) => {
+				context.set(path, value);
+				return value;
+			};
+		case 'value':
+			return () => clone(deepGet(context.get(), path));
+		case 'issues':
+		case 'allIssues': {
+			const key = buildPath(path);
+			const all = name === 'allIssues';
+			return () => {
+				const issues = context.issues(path, all)[key || '$'];
+				if (all) return issues?.map(publicIssue);
+				const own = issues?.filter((issue) => issue.name === key).map(publicIssue);
+				return own?.length ? own : undefined;
+			};
+		}
+		case 'touched':
+		case 'dirty': {
+			const key = buildPath(path);
+			return () => hasChange(name === 'dirty' ? context.dirty() : context.touched(), key);
+		}
+		case 'as':
+			return (type: string, option?: any, checked?: boolean) =>
+				inputAttributes(context, path, type, option, checked);
+	}
+}
+
+const warnedSites = new Set<string | undefined>();
+
+function warnEnumeration(): void {
+	const stack = new Error().stack;
+	if (warnedSites.has(stack)) return;
+	warnedSites.add(stack);
+	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()`'
+	);
+}
+
+function field(context: FieldContext, path: Path, target: object): any {
+	return new Proxy(target, {
+		get(target, property) {
+			if (typeof property === 'symbol') return Reflect.get(target, property);
+			const segment = /^\d+$/.test(property) ? Number.parseInt(property, 10) : property;
+			return field(context, [...path, segment], method(context, path, property) ?? {});
+		},
+		has(target, property) {
+			if (DEV && typeof property !== 'symbol') warnEnumeration();
+			return Reflect.has(target, property);
+		},
+		ownKeys(target) {
+			if (DEV) warnEnumeration();
+			return Reflect.ownKeys(target);
+		}
+	});
+}
+
+export function createFields(context: FieldContext): OpenFields {
+	return field(context, [], {});
+}

package/src/shared/hash.ts

@@ -0,0 +1,36 @@
+export type HashInput = string | ArrayBufferView;
+
+export function hash(...values: HashInput[]): string {
+	let state = 5381;
+	for (const value of values) {
+		if (typeof value === 'string') {
+			for (let index = value.length - 1; index >= 0; index--)
+				state = Math.imul(state, 33) ^ value.charCodeAt(index);
+		} else if (ArrayBuffer.isView(value)) {
+			const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+			for (let index = bytes.length - 1; index >= 0; index--)
+				state = Math.imul(state, 33) ^ bytes[index]!;
+		} else throw new TypeError('value must be a string or TypedArray');
+	}
+	return (state >>> 0).toString(36);
+}
+
+export function hashRequest(headers?: HeadersInit, body?: HashInput | null): string {
+	const values: HashInput[] = [];
+	if (headers) values.push([...new Headers(headers)].join(','));
+	if (body) values.push(body);
+	return hash(...values);
+}
+
+export function base64(bytes: Uint8Array): string {
+	let value = '';
+	for (let index = 0; index < bytes.length; index += 8192)
+		value += String.fromCharCode(...bytes.subarray(index, index + 8192));
+	return btoa(value);
+}
+
+export async function sha256(value: string): Promise<string> {
+	return base64(
+		new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(value)))
+	);
+}

package/src/shared/http.ts

@@ -0,0 +1,74 @@
+import { identity } from './identity.ts';
+
+export const methods = [
+	'GET',
+	'POST',
+	'PUT',
+	'PATCH',
+	'DELETE',
+	'OPTIONS',
+	'HEAD',
+	'QUERY'
+] as const;
+
+interface MediaRange {
+	major: string;
+	minor: string;
+	quality: number;
+	order: number;
+}
+
+export function negotiate(accept: string, available: readonly string[]): string | undefined {
+	const ranges: MediaRange[] = [];
+	for (const [order, part] of accept.split(',').entries()) {
+		const tokens = part.trim().split(';');
+		const media = tokens.shift()!.trim().split('/');
+		if (media.length !== 2 || !media[0] || !media[1]) continue;
+		const quality = tokens.map((token) => token.trim()).find((token) => token.startsWith('q='));
+		ranges.push({
+			major: media[0],
+			minor: media[1],
+			quality: quality ? Number(quality.slice(2)) : 1,
+			order
+		});
+	}
+	ranges.sort(
+		(a, b) =>
+			b.quality - a.quality ||
+			Number(a.minor === '*') - Number(b.minor === '*') ||
+			Number(a.major === '*') - Number(b.major === '*') ||
+			a.order - b.order
+	);
+	for (const range of ranges) {
+		for (const type of available) {
+			const [major, minor] = type.split('/');
+			if (
+				(range.major === '*' || range.major === major) &&
+				(range.minor === '*' || range.minor === minor)
+			)
+				return type;
+		}
+	}
+	return undefined;
+}
+
+export function matchesType(header: string | null | undefined, ...types: string[]): boolean {
+	return types.includes(header?.split(';', 1)[0]?.trim().toLowerCase() ?? '');
+}
+
+export function isForm(request: Request): boolean {
+	return matchesType(
+		request.headers.get('content-type'),
+		'application/x-www-form-urlencoded',
+		'multipart/form-data',
+		'text/plain',
+		`application/x-${identity.name}-formdata`
+	);
+}
+
+export function isEndpoint(request: Request): boolean {
+	if (!['GET', 'HEAD', 'POST'].includes(request.method)) return true;
+	if (request.method === 'POST' && request.headers.get(`x-${identity.name}-action`) === 'true')
+		return false;
+	return negotiate(request.headers.get('accept') ?? '*/*', ['*', 'text/html']) !== 'text/html';
+}

package/src/shared/identity.ts

@@ -0,0 +1,16 @@
+import type { Identity } from '../types/identity.ts';
+
+declare const __VIGLA_IDENTITY__: Identity | undefined;
+
+export const own: Identity = Object.freeze({
+	name: 'vigla',
+	product: 'Kit',
+	plugin: 'kit',
+	command: 'vigla-kit',
+	outDir: '.vigla',
+	assets: '/_vigla_assets',
+	announcer: 'vigla-announcer',
+	packages: ['@vigla/kit']
+});
+
+export const identity: Identity = typeof __VIGLA_IDENTITY__ === 'object' ? __VIGLA_IDENTITY__ : own;

package/src/shared/mime.ts

@@ -0,0 +1,6 @@
+import { lookup as lookupDefault } from 'mrmime';
+
+export function lookup(file: string): string | undefined {
+	const extension = file.slice(file.lastIndexOf('.') + 1).toLowerCase();
+	return extension === 'ico' ? 'image/x-icon' : lookupDefault(file);
+}

package/src/shared/outcomes.ts

@@ -0,0 +1,72 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type {
+	ActionFailure as FailureContract,
+	HttpError as HttpErrorContract,
+	Redirect as RedirectContract,
+	RedirectStatus,
+	ValidationError as ValidationContract
+} from '../types/outcomes.ts';
+
+export class HttpError implements HttpErrorContract {
+	status: number;
+	body: App.Error;
+
+	constructor(body: App.Error) {
+		this.body = body;
+		this.status = body.status;
+	}
+
+	toString(): string {
+		return JSON.stringify(this.body);
+	}
+}
+
+export class HandledError extends HttpError {}
+
+export class FrameworkError extends Error {
+	readonly status: number;
+	readonly text: string;
+	constructor(status: number, text: string, detail = text) {
+		super(detail);
+		this.status = status;
+		this.text = text;
+	}
+}
+
+export class Redirect implements RedirectContract {
+	status: RedirectStatus;
+	location: string;
+
+	constructor(status: RedirectStatus, location: string) {
+		try {
+			new Headers({ location });
+		} catch {
+			throw new Error(
+				`Invalid redirect location ${JSON.stringify(location)}: this string contains characters that cannot be used in HTTP headers`
+			);
+		}
+		this.status = status;
+		this.location = location;
+	}
+}
+
+export class ActionFailure<T = undefined> {
+	status: number;
+	data: T;
+
+	constructor(status: number, data: T) {
+		this.status = status;
+		this.data = data;
+	}
+}
+export interface ActionFailure<T = undefined> extends FailureContract<T> {}
+
+export class ValidationError extends Error implements ValidationContract {
+	issues: StandardSchemaV1.Issue[];
+
+	constructor(issues: StandardSchemaV1.Issue[]) {
+		super('Validation failed');
+		this.name = 'ValidationError';
+		this.issues = issues;
+	}
+}

package/src/shared/pathname.ts

@@ -0,0 +1,51 @@
+import type { NormalizedUrl } from '../types/outcomes.ts';
+
+export function hasDataSuffix(pathname: string): boolean {
+	return pathname.endsWith('/__data.json') || pathname.endsWith('.html__data.json');
+}
+export function hasResolutionSuffix(pathname: string): boolean {
+	return pathname.endsWith('/__route.js') || pathname.endsWith('.html__route.js');
+}
+export function addDataSuffix(pathname: string): string {
+	return pathname.endsWith('.html')
+		? pathname + '__data.json'
+		: pathname.replace(/\/$/, '') + '/__data.json';
+}
+export function addResolutionSuffix(pathname: string): string {
+	return pathname.endsWith('.html')
+		? pathname + '__route.js'
+		: pathname.replace(/\/$/, '') + '/__route.js';
+}
+export function stripDataSuffix(pathname: string): string {
+	return pathname.endsWith('.html__data.json')
+		? pathname.slice(0, -'__data.json'.length)
+		: pathname.slice(0, -'/__data.json'.length);
+}
+export function stripResolutionSuffix(pathname: string): string {
+	return pathname.endsWith('.html__route.js')
+		? pathname.slice(0, -'__route.js'.length)
+		: pathname.slice(0, -'/__route.js'.length);
+}
+export function normalizeUrl(input: URL | string): NormalizedUrl {
+	const url = new URL(input, 'a://a');
+	const suffix = hasResolutionSuffix(url.pathname)
+		? 'route'
+		: hasDataSuffix(url.pathname)
+			? 'data'
+			: null;
+	const trailingSlash = url.pathname !== '/' && url.pathname.endsWith('/');
+	if (suffix === 'route') url.pathname = stripResolutionSuffix(url.pathname);
+	else if (suffix === 'data') url.pathname = stripDataSuffix(url.pathname);
+	else if (trailingSlash) url.pathname = url.pathname.slice(0, -1);
+	return {
+		url,
+		wasNormalized: suffix !== null || trailingSlash,
+		denormalize(input = url) {
+			const result = new URL(input, url);
+			if (suffix === 'route') result.pathname = addResolutionSuffix(result.pathname);
+			else if (suffix === 'data') result.pathname = addDataSuffix(result.pathname);
+			else if (trailingSlash && !result.pathname.endsWith('/')) result.pathname += '/';
+			return result;
+		}
+	};
+}

package/src/shared/redirect.ts

@@ -0,0 +1,47 @@
+import type { RedirectOptions } from '../types/outcomes.ts';
+import type { Diagnostics } from './diagnostics.ts';
+import {
+	redirect_external_javascript,
+	redirect_external_not_allowed,
+	redirect_external_not_in_allowlist,
+	redirect_external_option_invalid
+} from './errors.ts';
+
+const base = 'https://redirect.invalid';
+
+export function matchesOrigin(location: string, allowed: string): boolean {
+	if (location === allowed) return true;
+	try {
+		const origin = new URL(allowed);
+		const target = new URL(location, origin);
+		return target.protocol === origin.protocol && target.host === origin.host;
+	} catch {
+		return false;
+	}
+}
+
+export function validateRedirect(
+	d: Diagnostics,
+	location: string,
+	options?: RedirectOptions,
+	origin?: string
+): void {
+	if (matchesOrigin(location, origin ?? base)) return;
+	const external = options?.external;
+	const values = { location: JSON.stringify(location) };
+	if (!external) redirect_external_not_allowed(values, d);
+	if (external === true) {
+		let protocol: string | undefined;
+		try {
+			protocol = new URL(location, base).protocol;
+		} catch {}
+		if (protocol === 'javascript:' || protocol === 'data:') redirect_external_javascript(values, d);
+		return;
+	}
+	if (Array.isArray(external)) {
+		if (!external.some((allowed) => matchesOrigin(location, allowed)))
+			redirect_external_not_in_allowlist(values, d);
+		return;
+	}
+	redirect_external_option_invalid(d);
+}