@vigla/kit 0.0.0-stage → 0.1.1

package/src/types/remote-functions.ts

@@ -0,0 +1,114 @@
+import type { StandardSchemaV1 as Schema } from '@standard-schema/spec';
+import type { RemoteFormInput, RemoteFormInvalidField } from './fields.ts';
+import type { RemoteForm } from './remote-form.ts';
+import type {
+	LiveResult,
+	PrerenderOptions,
+	RemoteCommand,
+	RemoteLiveQueryFunction,
+	RemoteLiveQueryRequestedResult,
+	RemotePrerenderFunction,
+	RemoteQueryFunction,
+	RemoteQueryRequestedResult
+} from './remote.ts';
+import type { IsAny, MaybePromise } from './value.ts';
+
+export interface Command {
+	<Output>(fn: () => MaybePromise<Output>): RemoteCommand<void, Output>;
+	<Input, Output>(
+		validation: 'unchecked',
+		fn: (arg: Input) => MaybePromise<Output>
+	): RemoteCommand<Input, Output>;
+	<S extends Schema, Output>(
+		validation: S,
+		fn: (arg: Schema.InferOutput<S>) => MaybePromise<Output>
+	): RemoteCommand<Schema.InferInput<S>, Output>;
+}
+export interface Query {
+	<Output>(fn: () => MaybePromise<Output>): RemoteQueryFunction<void, Output>;
+	<Input, Output>(
+		validation: 'unchecked',
+		fn: (arg: Input) => MaybePromise<Output>
+	): RemoteQueryFunction<Input, Output>;
+	<S extends Schema, Output>(
+		validation: S,
+		fn: (arg: Schema.InferOutput<S>) => MaybePromise<Output>
+	): RemoteQueryFunction<Schema.InferInput<S>, Output, Schema.InferOutput<S>>;
+	batch: BatchQuery;
+	live: LiveQuery;
+}
+export interface BatchQuery {
+	<Input, Output>(
+		validation: 'unchecked',
+		fn: (args: Input[]) => MaybePromise<(arg: Input, index: number) => Output>
+	): RemoteQueryFunction<Input, Output>;
+	<S extends Schema, Output>(
+		validation: S,
+		fn: (
+			args: Schema.InferOutput<S>[]
+		) => MaybePromise<(arg: Schema.InferOutput<S>, index: number) => Output>
+	): RemoteQueryFunction<Schema.InferInput<S>, Output, Schema.InferOutput<S>>;
+}
+export interface LiveQuery {
+	<Output>(fn: (arg: void) => LiveResult<Output>): RemoteLiveQueryFunction<void, Output>;
+	<Input, Output>(
+		validation: 'unchecked',
+		fn: (arg: Input) => LiveResult<Output>
+	): RemoteLiveQueryFunction<Input, Output>;
+	<S extends Schema, Output>(
+		validation: S,
+		fn: (arg: Schema.InferOutput<S>) => LiveResult<Output>
+	): RemoteLiveQueryFunction<Schema.InferInput<S>, Output, Schema.InferOutput<S>>;
+}
+export interface Prerender {
+	<Output>(
+		fn: () => MaybePromise<Output>,
+		options?: PrerenderOptions<void>
+	): RemotePrerenderFunction<void, Output>;
+	<Input, Output>(
+		validation: 'unchecked',
+		fn: (arg: Input) => MaybePromise<Output>,
+		options?: PrerenderOptions<Input>
+	): RemotePrerenderFunction<Input, Output>;
+	<S extends Schema, Output>(
+		validation: S,
+		fn: (arg: Schema.InferOutput<S>) => MaybePromise<Output>,
+		options?: PrerenderOptions<Schema.InferInput<S>>
+	): RemotePrerenderFunction<Schema.InferInput<S>, Output>;
+}
+export type RequiredBoolean<T> =
+	IsAny<T> extends true
+		? never
+		: [T] extends [boolean]
+			? true
+			: T extends Array<infer Element>
+				? RequiredBoolean<Element>
+				: T extends Record<string, any>
+					? { [K in keyof T]: RequiredBoolean<T[K]> }[keyof T]
+					: never;
+export interface Form {
+	<Output>(fn: () => MaybePromise<Output>): RemoteForm<void, Output>;
+	<Input extends RemoteFormInput, Output>(
+		validation: 'unchecked',
+		fn: (input: Input, issue: RemoteFormInvalidField<Input>) => MaybePromise<Output>
+	): RemoteForm<Input, Output>;
+	<S extends Schema<RemoteFormInput, Record<string, any>>, Output>(
+		validation: true extends RequiredBoolean<Schema.InferInput<S>>
+			? 'Error: All booleans in form schemas must be optional (e.g. `v.optional(v.boolean(), false)`) because checkbox inputs do not send a false value when unchecked.'
+			: S,
+		fn: (
+			input: Schema.InferOutput<S>,
+			issue: RemoteFormInvalidField<Schema.InferInput<S>>
+		) => MaybePromise<Output>
+	): RemoteForm<Schema.InferInput<S>, Output>;
+}
+export interface Requested {
+	<Input, Output, Validated = Input>(
+		query: RemoteQueryFunction<Input, Output, Validated>,
+		limit: number
+	): RemoteQueryRequestedResult<Validated, Output>;
+	<Input, Output, Validated = Input>(
+		query: RemoteLiveQueryFunction<Input, Output, Validated>,
+		limit: number
+	): RemoteLiveQueryRequestedResult<Validated, Output>;
+}

package/src/types/remote.ts

@@ -0,0 +1,75 @@
+import type { MaybePromise } from './value.ts';
+
+export type RemoteResource<T> = Promise<T> & {
+	readonly error: App.Error | undefined;
+	readonly loading: boolean;
+} & ({ readonly current: undefined; ready: false } | { readonly current: T; ready: true });
+export type RemoteQuery<T> = RemoteResource<T> & {
+	set(value: T): void;
+	refresh(): Promise<void>;
+	withOverride(update: (value: T) => T): RemoteQueryOverride;
+};
+export type RemoteLiveQuery<T> = RemoteResource<T> &
+	AsyncIterable<T> & {
+		readonly connected: boolean;
+		readonly done: boolean;
+		reconnect(): Promise<void>;
+	};
+export type RemoteQueryOverride = () => void;
+export type RemoteQueryUpdate =
+	| RemoteQuery<any>
+	| RemoteLiveQuery<any>
+	| RemoteQueryFunction<any, any>
+	| RemoteLiveQueryFunction<any, any>
+	| RemoteQueryOverride;
+export interface UpdatingPromise<Output> extends Promise<Output> {
+	updates(...updates: RemoteQueryUpdate[]): Promise<Output>;
+}
+export interface RemoteCommand<Input, Output> {
+	(arg: undefined extends Input ? Input | void : Input): UpdatingPromise<Output>;
+	readonly pending: number;
+}
+export type RemotePrerenderFunction<Input, Output> = (
+	arg: undefined extends Input ? Input | void : Input
+) => RemoteResource<Output>;
+declare const validated: unique symbol;
+export type RemoteQueryFunction<Input, Output, Validated = Input> = ((
+	arg: undefined extends Input ? Input | void : Input
+) => RemoteQuery<Output>) & { readonly [validated]?: Validated };
+export type RemoteLiveQueryFunction<Input, Output, Validated = Input> = ((
+	arg: undefined extends Input ? Input | void : Input
+) => RemoteLiveQuery<Output>) & { readonly [validated]?: Validated };
+export interface RequestedEntry<Validated, Output> {
+	arg: Validated;
+	query: RemoteQuery<Output>;
+	ignore(): void;
+}
+export interface RemoteLiveQueryRequestedEntry<Validated, Output> {
+	arg: Validated;
+	query: RemoteLiveQuery<Output>;
+	ignore(): void;
+}
+export interface RemoteQueryRequestedResult<Validated, Output>
+	extends
+		Iterable<RequestedEntry<Validated, Output>>,
+		AsyncIterable<RequestedEntry<Validated, Output>> {
+	refreshAll(): Promise<void>;
+	ignoreAll(): Promise<void>;
+}
+export interface RemoteLiveQueryRequestedResult<Validated, Output>
+	extends
+		Iterable<RemoteLiveQueryRequestedEntry<Validated, Output>>,
+		AsyncIterable<RemoteLiveQueryRequestedEntry<Validated, Output>> {
+	reconnectAll(): Promise<void>;
+	ignoreAll(): Promise<void>;
+}
+export type RequestedResult<Validated, Output> =
+	| RemoteQueryRequestedResult<Validated, Output>
+	| RemoteLiveQueryRequestedResult<Validated, Output>;
+export type LiveResult<T> = MaybePromise<
+	AsyncGenerator<T> | AsyncIterator<T> | AsyncIterable<T> | Generator<T> | Iterator<T> | Iterable<T>
+>;
+export interface PrerenderOptions<Input> {
+	inputs?: () => MaybePromise<Input[]>;
+	dynamic?: boolean;
+}

package/src/types/request.ts

@@ -0,0 +1,122 @@
+import type { Span } from '@opentelemetry/api';
+import type { ParseOptions, SerializeOptions, parseSetCookie } from 'cookie';
+import type { LayoutParams, RouteId } from '$app/types';
+import type { MaybePromise } from './value.ts';
+import type { ParamValue } from './params.ts';
+import type { AsyncStore } from 'vigla';
+import type { Read } from './internal/server.ts';
+
+export interface CookieValue {
+	name: string;
+	value: string;
+}
+export interface Cookies {
+	get(name: string, options?: ParseOptions): string | undefined;
+	getAll(options?: ParseOptions): CookieValue[];
+	set(name: string, value: string, options?: SerializeOptions): void;
+	delete(name: string, options?: SerializeOptions): void;
+	parse: typeof parseSetCookie;
+	serialize(name: string, value: string, options?: SerializeOptions): string;
+}
+export interface Tracing {
+	enabled: boolean;
+	root: Span;
+	current: Span;
+}
+export interface NavigationEvent<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Id extends RouteId | null = RouteId | null
+> {
+	params: Params;
+	route: { id: Id };
+	url: URL;
+}
+export interface RequestEvent<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Id extends RouteId | null = RouteId | null
+> {
+	readonly cookies: Cookies;
+	readonly fetch: typeof fetch;
+	readonly getClientAddress: () => string;
+	readonly locals: App.Locals;
+	readonly params: Params;
+	readonly platform: Readonly<App.Platform> | undefined;
+	readonly request: Request;
+	readonly route: { id: Id };
+	readonly setHeaders: (headers: Record<string, string>) => void;
+	readonly url: URL;
+	readonly isDataRequest: boolean;
+	readonly isSubRequest: boolean;
+	readonly isRemoteRequest: boolean;
+	readonly tracing: Tracing;
+}
+export interface LoadEvent<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Data extends Record<string, unknown> | null = Record<string, any> | null,
+	Parent extends Record<string, unknown> = Record<string, any>,
+	Id extends RouteId | null = RouteId | null
+> extends NavigationEvent<Params, Id> {
+	fetch: typeof fetch;
+	data: Data;
+	setHeaders(headers: Record<string, string>): void;
+	parent(): Promise<Parent>;
+	depends(...dependencies: `${string}:${string}`[]): void;
+	untrack<T>(fn: () => T): T;
+	tracing: Tracing;
+}
+export type Load<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Data extends Record<string, unknown> | null = Record<string, any> | null,
+	Parent extends Record<string, unknown> = Record<string, any>,
+	Output extends Record<string, unknown> | void = Record<string, any> | void,
+	Id extends RouteId | null = RouteId | null
+> = (event: LoadEvent<Params, Data, Parent, Id>) => MaybePromise<Output>;
+
+export interface ServerLoadEvent<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Parent extends Record<string, any> = Record<string, any>,
+	Id extends RouteId | null = RouteId | null
+> extends RequestEvent<Params, Id> {
+	parent(): Promise<Parent>;
+	depends(...dependencies: string[]): void;
+	untrack<T>(fn: () => T): T;
+	tracing: Tracing;
+}
+export type ServerLoad<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Parent extends Record<string, any> = Record<string, any>,
+	Output extends Record<string, any> | void = Record<string, any> | void,
+	Id extends RouteId | null = RouteId | null
+> = (event: ServerLoadEvent<Params, Parent, Id>) => MaybePromise<Output>;
+export type Action<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Output extends Record<string, any> | void = Record<string, any> | void,
+	Id extends RouteId | null = RouteId | null
+> = (event: RequestEvent<Params, Id>) => MaybePromise<Output>;
+export type Actions<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Output extends Record<string, any> | void = Record<string, any> | void,
+	Id extends RouteId | null = RouteId | null
+> = Record<string, Action<Params, Output, Id>>;
+export type RequestHandler<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Id extends RouteId | null = RouteId | null
+> = (event: RequestEvent<Params, Id>) => MaybePromise<Response>;
+export interface Snapshot<T = any> {
+	capture(): T;
+	restore(value: T): void;
+}
+export interface ServerInitOptions {
+	env: Record<string, string | undefined>;
+	read?: Read;
+	scope?: AsyncStore;
+}
+export interface RequestOptions {
+	getClientAddress(): string;
+	platform?: App.Platform;
+	read?: Read;
+}
+export interface Server {
+	init(options: ServerInitOptions): Promise<void>;
+	respond(request: Request, options: RequestOptions): Promise<Response>;
+}

package/src/types/state.ts

@@ -0,0 +1,30 @@
+import type { LayoutParams, ResolvedPathname, RouteId } from '$app/types';
+import type { ParamValue } from './params.ts';
+
+export type ReadonlyURLSearchParams = Omit<URLSearchParams, 'set' | 'append' | 'delete' | 'sort'>;
+export type ReadonlyURL = Readonly<
+	Omit<URL, 'searchParams'> & { searchParams: ReadonlyURLSearchParams }
+>;
+export interface ShallowNavigation<Params extends Record<string, ParamValue> = LayoutParams<'/'>> {
+	params: Params | null;
+	route: { id: RouteId } | null;
+	url: ReadonlyURL;
+}
+export interface Page<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Id extends RouteId | null = RouteId | null
+> {
+	url: ReadonlyURL & { readonly pathname: ResolvedPathname | (string & {}) };
+	params: Params;
+	route: { id: Id };
+	status: number;
+	error: App.Error | null;
+	data: App.PageData & Record<string, any>;
+	state: App.PageState;
+	shallow: ShallowNavigation<LayoutParams<'/'> | Params> | null;
+	form: any;
+}
+export interface Updated {
+	readonly current: boolean;
+	check(): Promise<boolean>;
+}

package/src/types/value.ts

@@ -0,0 +1,11 @@
+export type MaybePromise<T> = T | Promise<T>;
+export type DeepPartial<T> = T extends Record<PropertyKey, unknown> | unknown[]
+	? { [K in keyof T]?: DeepPartial<T[K]> }
+	: T | undefined;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type UnionKeys<T> = T extends unknown ? keyof T : never;
+export type UnionValue<T, K extends PropertyKey> = T extends unknown
+	? K extends keyof T
+		? T[K]
+		: never
+	: never;

package/src/vite/assets.ts

@@ -0,0 +1,42 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { serveFile } from '../node/static.ts';
+import { escapeHtml } from '../shared/escape.ts';
+import { negotiate } from '../shared/http.ts';
+import type { Project } from './project.ts';
+
+export function serveAsset(
+	project: Project,
+	request: IncomingMessage,
+	response: ServerResponse,
+	pathname: string
+): boolean {
+	const prefix = project.config.paths.assets ? project.identity.assets : project.config.paths.base;
+	if (!pathname.startsWith(prefix + '/')) return false;
+	return serveFile({
+		directory: project.config.files.assets,
+		pathname: pathname.slice(prefix.length),
+		request,
+		response
+	});
+}
+
+export function outsideBase(
+	request: IncomingMessage,
+	response: ServerResponse,
+	base: string
+): void {
+	const html =
+		negotiate(request.headers.accept ?? '*', ['text/plain', 'text/html']) === 'text/html';
+	if (request.url === '/' && html) {
+		response.writeHead(307, { location: base });
+		response.end();
+		return;
+	}
+	const target = escapeHtml(base + request.url);
+	response.writeHead(404, {
+		'content-type': html ? 'text/html; charset=utf-8' : 'text/plain; charset=utf-8'
+	});
+	response.end(
+		`The server is configured with a public base URL of ${escapeHtml(base)} - did you mean to visit ${html ? `<a href="${escapeHtml(base + request.url, true)}">${target}</a>` : target} instead?`
+	);
+}