@vigla/kit 0.0.0-stage → 0.1.0

package/src/types/internal/server.ts

@@ -0,0 +1,372 @@
+import type { Attributes, Span } from '@opentelemetry/api';
+import type { AsyncStore, Owner } from 'vigla';
+import type { Component, Format } from 'vigla/server';
+import type { CspConfig } from '../csp.ts';
+import type { Emulator, PrerenderOption } from '../builder.ts';
+import type {
+	Handle,
+	HandleFetch,
+	HandleServerError,
+	Reroute,
+	ResolveOptions,
+	ServerInit,
+	Transport
+} from '../hooks.ts';
+import type { ParamMatcher, ParamValue } from '../params.ts';
+import type {
+	Actions,
+	Load,
+	RequestEvent,
+	RequestHandler,
+	Server,
+	ServerInitOptions,
+	ServerLoad
+} from '../request.ts';
+import type { Page } from '../state.ts';
+import type { MaybePromise } from '../value.ts';
+import type { PageBranch, RouteParam } from './routes.ts';
+import type { TrailingSlash } from './data.ts';
+import type { RemoteExport, RemoteRequestState } from './remote.ts';
+
+export type { TrailingSlash } from './data.ts';
+export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'QUERY';
+export type Read = (file: string) => MaybePromise<ReadableStream<Uint8Array> | null>;
+
+export interface FontDependency {
+	file: string;
+	filename: string;
+}
+
+export interface UniversalNode {
+	load?: Load<Record<string, ParamValue>>;
+	prerender?: PrerenderOption;
+	ssr?: boolean;
+	csr?: boolean;
+	trailingSlash?: TrailingSlash;
+	config?: Record<string, any>;
+	entries?: EntryGenerator;
+}
+
+export interface ServerNode {
+	load?: ServerLoad<Record<string, ParamValue>>;
+	prerender?: PrerenderOption;
+	ssr?: boolean;
+	csr?: boolean;
+	trailingSlash?: TrailingSlash;
+	actions?: Actions<Record<string, ParamValue>>;
+	config?: Record<string, any>;
+	entries?: EntryGenerator;
+}
+
+export type EntryGenerator = () => MaybePromise<Array<Record<string, string>>>;
+export type ComponentLoader = () => Promise<Component<any>>;
+export type NodeLoader = () => Promise<PageNode>;
+
+export type Style = (assets: string) => string;
+
+export interface PageNode {
+	index: number;
+	imports: string[];
+	stylesheets: string[];
+	fonts: FontDependency[];
+	universal_id?: string;
+	server_id?: string;
+	inline_styles?(): MaybePromise<Record<string, string | Style>>;
+	component?: ComponentLoader;
+	universal?: UniversalNode;
+	server?: ServerNode;
+}
+
+export type Endpoint = Partial<Record<HttpMethod, RequestHandler<Record<string, ParamValue>>>> & {
+	prerender?: PrerenderOption;
+	trailingSlash?: TrailingSlash;
+	config?: Record<string, any>;
+	entries?: EntryGenerator;
+	fallback?: RequestHandler<Record<string, ParamValue>>;
+};
+
+export interface ServerRoute {
+	id: string;
+	pattern: RegExp;
+	params: RouteParam[];
+	page: PageBranch | null;
+	endpoint: (() => Promise<Endpoint>) | null;
+	endpoint_id?: string;
+}
+
+export interface ClientRoute {
+	id: string;
+	pattern: RegExp;
+	params: RouteParam[];
+	errors: Array<number | undefined>;
+	layouts: Array<[has_server_load: boolean, node_id: number] | undefined>;
+	leaf: [has_server_load: boolean, node_id: number];
+}
+
+export interface ClientBuild {
+	start: string;
+	app?: string;
+	imports: string[];
+	nodes?: Array<string | undefined>;
+	css?: Array<string[] | undefined>;
+	routes?: ClientRoute[];
+	stylesheets: string[];
+	fonts: FontDependency[];
+	uses_env_dynamic_public: boolean;
+	inline?: { script: string; style: Style | undefined };
+}
+
+export interface RemoteModule {
+	default: Record<string, RemoteExport>;
+}
+
+export interface ServerManifest {
+	app_dir: string;
+	app_path: string;
+	assets: Set<string>;
+	mime_types: Record<string, string>;
+	client: ClientBuild | null;
+	nodes: NodeLoader[];
+	remotes: Record<string, () => Promise<RemoteModule>>;
+	routes: ServerRoute[];
+	prerendered_routes: Set<string>;
+	matchers(): Promise<Record<string, ParamMatcher>>;
+	server_assets: Record<string, number>;
+}
+
+export interface ServerHooks {
+	handle?: Handle;
+	handleFetch?: HandleFetch;
+	handleError?: HandleServerError;
+	reroute?: Reroute;
+	transport?: Transport;
+	init?: ServerInit;
+}
+
+export interface AppTemplateValues {
+	head: string;
+	body: string;
+	assets: string;
+	nonce: string;
+	env: Record<string, unknown>;
+}
+
+export interface ErrorTemplateValues {
+	message: string;
+	status: number;
+}
+
+export interface ServerTemplates {
+	app(values: AppTemplateValues): string;
+	error(values: ErrorTemplateValues): string;
+}
+
+export interface ServerPaths {
+	base: string;
+	assets: string;
+	origin?: string;
+	relative: boolean;
+}
+
+export interface Environment {
+	public: Record<string, unknown>;
+	private: Record<string, unknown>;
+	rendered: Record<string, unknown>;
+}
+
+export interface ServerEnvironment {
+	set(values: Record<string, string | undefined>): MaybePromise<Environment>;
+}
+
+export interface ServerVersion {
+	name: string;
+	pollInterval: number;
+}
+
+export interface ServerOutput {
+	bundleStrategy: 'split' | 'single' | 'inline';
+	linkHeaderPreload: boolean;
+}
+
+export interface ServerRouter {
+	type: 'pathname' | 'hash';
+	resolution: 'client' | 'server';
+}
+
+export interface RemoteCall {
+	id: string;
+	name: string;
+	argument?: string;
+	store: RequestStore;
+}
+
+export interface ServerCsrf {
+	checkOrigin: boolean;
+	trustedOrigins: string[];
+}
+
+export interface ServerWorker {
+	file: string;
+	options: RegistrationOptions;
+}
+
+export interface ServerTracing {
+	server: boolean;
+}
+
+export interface ServerOptions {
+	global: string;
+	root: Component<any>;
+	format?: Format;
+	extension: string;
+	adapter: string;
+	getHooks(): Promise<ServerHooks>;
+	templates: ServerTemplates;
+	appTemplateContainsNonce: boolean;
+	csp: CspConfig;
+	csrf: ServerCsrf;
+	paths: ServerPaths;
+	env: ServerEnvironment;
+	serviceWorker: ServerWorker | null;
+	version: ServerVersion;
+	output: ServerOutput;
+	router: ServerRouter;
+	embedded: boolean;
+	tracing: ServerTracing;
+	dev: boolean;
+	building: boolean;
+	prerendering: boolean;
+	fixStack?(error: Error): Error;
+	remote?(call: RemoteCall): Promise<Response>;
+}
+
+export interface Uses {
+	dependencies: Set<string>;
+	params: Set<string>;
+	parent: boolean;
+	route: boolean;
+	url: boolean;
+	search_params: Set<string>;
+}
+
+export interface ServerDataNode {
+	type: 'data';
+	data: Record<string, any> | null;
+	uses: Uses;
+	slash?: TrailingSlash;
+}
+
+export interface Fetched {
+	url: string;
+	method: string;
+	request_headers?: Headers;
+	request_body?: string | ArrayBufferView;
+	response: Response;
+	response_body: string;
+	is_b64: boolean;
+}
+
+export interface PrerenderDependency {
+	response: Response;
+	body: string | Uint8Array | null;
+}
+
+export interface PrerenderState {
+	fallback: boolean;
+	insideReroute: boolean;
+	dependencies: Map<string, PrerenderDependency>;
+	remoteResponses?: Map<string, Promise<any>>;
+}
+
+export interface RespondOptions {
+	getClientAddress?(): string;
+	platform?: App.Platform;
+	emulator?: Emulator;
+	read?: Read;
+	prerendering?: PrerenderState;
+}
+
+export interface ServerInstance {
+	init(options: ServerInitOptions): Promise<void>;
+	respond(request: Request, options: RespondOptions): Promise<Response>;
+}
+
+export interface ServerConfigureOptions {
+	manifest?: ServerManifest;
+	env?: Record<string, string | undefined>;
+	read?: Read;
+	scope?: AsyncStore;
+	assets?: string;
+	building?: boolean;
+	prerendering?: boolean;
+	fix_stack_trace?(error: Error): void;
+}
+
+export interface ConfiguredServer {
+	init(): Promise<void>;
+	respond(request: Request, options: RespondOptions): Promise<Response>;
+	set_env(env: Record<string, string | undefined>): void;
+}
+
+export interface ServerModule {
+	configure(options: ServerConfigureOptions): Promise<ConfiguredServer>;
+	create_server(manifest: ServerManifest): Server;
+	Server: new (manifest: ServerManifest) => Server;
+	format_response(status: number, request: Request): string;
+}
+
+export interface ServerInternalModule {
+	options: ServerOptions;
+}
+
+export interface RequestState {
+	read?: Read;
+	emulator?: Emulator;
+	depth: number;
+	error: boolean;
+	rerouted: string | null;
+	prerendering?: PrerenderState;
+	prerenderDefault?: PrerenderOption;
+	prerenderCache?: string;
+	fetched: Fetched[];
+	resolveOptions: ResolveOptions;
+	isRendering: boolean;
+	active: boolean;
+}
+
+export interface RequestStore {
+	event: RequestEvent<Record<string, ParamValue>>;
+	state: RequestState;
+	owner: Owner;
+	manifest: ServerManifest;
+	options: ServerOptions;
+	environment: Environment;
+	hooks: ServerHooks;
+	tracer: SpanRecorder;
+	remote: RemoteRequestState;
+}
+
+export interface SpanRecorder {
+	span<T>(name: string, attributes: Attributes, fn: (span: Span) => Promise<T>): Promise<T>;
+}
+
+export interface RenderBranch {
+	component: Component<any>;
+	error: Component<any> | null;
+	data: Record<string, any>;
+	child: RenderBranch | null;
+}
+
+export interface RootProps extends Record<string, unknown> {
+	page: Page<Record<string, ParamValue>>;
+	tree: RenderBranch;
+	form: unknown;
+	error: App.Error | null;
+	components: unknown[];
+	onerror(error: unknown): void;
+}
+
+export interface MatchedRoute {
+	route: ServerRoute;
+	params: Record<string, ParamValue>;
+}

package/src/types/navigation.ts

@@ -0,0 +1,95 @@
+import type { LayoutParams, RouteId } from '$app/types';
+import type { Snapshot } from './request.ts';
+import type { MaybePromise } from './value.ts';
+import type { ParamValue } from './params.ts';
+
+export interface ScrollPosition {
+	x: number;
+	y: number;
+}
+export interface NavigationTarget<
+	Params extends Record<string, ParamValue> = LayoutParams<'/'>,
+	Id extends RouteId | null = RouteId | null
+> {
+	params: Params | null;
+	route: { id: Id | null };
+	url: URL;
+	scroll: ScrollPosition | null;
+}
+export type Invalidation = string | URL | ((url: URL) => boolean);
+export interface GotoOptions {
+	replace?: boolean;
+	shallow?: boolean;
+	reset?: boolean;
+	refreshAll?: boolean;
+	invalidate?: Invalidation[];
+	state?: App.PageState;
+	persistState?: boolean;
+}
+export type ShallowCaller = 'pushState' | 'replaceState';
+export type NavigationType = 'enter' | 'form' | 'leave' | 'link' | 'goto' | 'popstate';
+export interface NavigationBase {
+	type: NavigationType;
+	shallow: boolean;
+	from: NavigationTarget | null;
+	to: NavigationTarget | null;
+	willUnload: boolean;
+	complete: Promise<void>;
+}
+export interface NavigationEnter extends NavigationBase {
+	type: 'enter';
+	delta?: undefined;
+	event?: undefined;
+}
+export interface NavigationGoto extends NavigationBase {
+	type: 'goto';
+}
+export interface NavigationLeave extends NavigationBase {
+	type: 'leave';
+}
+export interface NavigationFormSubmit extends NavigationBase {
+	type: 'form';
+	event: SubmitEvent;
+}
+export interface NavigationPopState extends NavigationBase {
+	type: 'popstate';
+	delta: number;
+	event: PopStateEvent;
+}
+export interface NavigationLink extends NavigationBase {
+	type: 'link';
+	event: PointerEvent;
+}
+export type NavigationExternal = NavigationGoto | NavigationLeave;
+export type Navigation =
+	| NavigationExternal
+	| NavigationFormSubmit
+	| NavigationPopState
+	| NavigationLink;
+export type BeforeNavigate = Navigation & { cancel(): void };
+export type OnNavigate = Navigation & {
+	type: Exclude<NavigationType, 'enter' | 'leave'>;
+	willUnload: false;
+};
+export type AfterNavigate = (Navigation | NavigationEnter) & {
+	type: Exclude<NavigationType, 'leave'>;
+	willUnload: false;
+};
+export interface SnapshotOptions<T> extends Snapshot<T> {
+	id?: string;
+	reset?: () => void;
+}
+export type PreloadResult = (
+	| { type: 'loaded'; data: Record<string, any> }
+	| { type: 'redirect'; location: string }
+	| { type: 'error'; error: App.Error }
+) & { status: number };
+export interface IdleNavigation {
+	from: null;
+	to: null;
+	type: null;
+	willUnload: null;
+	delta: null;
+	complete: null;
+}
+export type NavigationCallback = (navigation: OnNavigate) => MaybePromise<(() => void) | void>;

package/src/types/node.ts

@@ -0,0 +1,10 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+
+export interface RequestInput {
+	request: IncomingMessage;
+	response?: ServerResponse;
+	base: string;
+	bodySizeLimit?: number;
+}
+export type GetRequest = (input: RequestInput) => Request;
+export type SetResponse = (response: ServerResponse, result: Response) => void;

package/src/types/outcomes.ts

@@ -0,0 +1,63 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+export interface ErrorBody {
+	status: number;
+	message: string;
+}
+
+export type ErrorProperties = Omit<App.Error, keyof ErrorBody>;
+export type ErrorOverrides = ErrorProperties & Partial<ErrorBody>;
+export type ErrorReturn = ErrorOverrides | (ErrorBody extends App.Error ? void : never);
+
+export interface ErrorFunction {
+	(status: ErrorBody extends App.Error ? number : never, message?: string): never;
+	(
+		status: number,
+		message: string,
+		properties: keyof ErrorProperties extends never ? never : ErrorProperties
+	): never;
+}
+
+export interface HttpError {
+	status: number;
+	body: App.Error;
+}
+
+export type RedirectStatus = 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
+export interface Redirect {
+	status: RedirectStatus;
+	location: string;
+}
+export interface RedirectOptions {
+	external?: boolean | string[];
+}
+
+declare const failure: unique symbol;
+export interface ActionFailure<T = undefined> {
+	status: number;
+	data: T;
+	[failure]: true;
+}
+
+export interface ValidationError {
+	issues: StandardSchemaV1.Issue[];
+}
+
+export interface NormalizedUrl {
+	url: URL;
+	wasNormalized: boolean;
+	denormalize(url?: string | URL): URL;
+}
+
+export type LoadProperties<T extends Record<string, any> | void> = T extends void ? undefined : T;
+
+type ActionData<T> = T extends ActionFailure<infer Data> ? Data : T extends void ? undefined : T;
+type UnionKeys<T> = T extends unknown ? keyof T : never;
+type AccessibleUnion<T, Keys extends PropertyKey = UnionKeys<T>> = T extends unknown
+	? T & { [K in Exclude<Keys, keyof T>]?: never }
+	: never;
+export type AwaitedActions<T extends Record<string, (...args: any) => any>> = AccessibleUnion<
+	{
+		[K in keyof T]: ActionData<Awaited<ReturnType<T[K]>>>;
+	}[keyof T]
+>;

package/src/types/params.ts

@@ -0,0 +1,34 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+export type ParamMatcher<Output = any> = StandardSchemaV1<string, Output>;
+export type ParamValue = string | number | boolean | bigint;
+export type ParamDefinition =
+	| ((value: string) => ParamValue | undefined)
+	| StandardSchemaV1<string, ParamValue>;
+export type ParamEntry<T> =
+	T extends StandardSchemaV1<any, any>
+		? StandardSchemaV1.InferOutput<T> extends ParamValue
+			? StandardSchemaV1<any, T>
+			: StandardSchemaV1<any, never>
+		: T extends (value: string) => infer Output
+			? StandardSchemaV1<
+					any,
+					Exclude<Output, undefined> extends ParamValue ? Exclude<Output, undefined> : never
+				>
+			: never;
+export type DefinedParams<T extends Record<string, ParamDefinition>> = {
+	readonly [K in keyof T]: ParamEntry<T[K]>;
+};
+export type MatcherParam<T extends StandardSchemaV1<any, any>> =
+	T extends StandardSchemaV1<any, infer Output>
+		? Output extends ParamValue
+			? Output
+			: Output extends StandardSchemaV1<any, any>
+				? StandardSchemaV1.InferOutput<Output> extends ParamValue
+					? StandardSchemaV1.InferOutput<Output>
+					: never
+				: never
+		: never;
+export declare function defineParams<T extends Record<string, ParamDefinition>>(
+	definitions: T
+): DefinedParams<T>;

package/src/types/paths.ts

@@ -0,0 +1,31 @@
+import type { EndpointRouteId, PageRouteId, RouteId, RouteParams } from '$app/types';
+
+export type StripFragment<T extends string> = T extends `${infer Path}?${string}`
+	? Path
+	: T extends `${infer Path}#${string}`
+		? Path
+		: T;
+export type ResolveArgs<T> =
+	RouteParams<StripFragment<T & string> & RouteId> extends Record<string, never>
+		? [route: T]
+		: T extends `/${string}`
+			? StripFragment<T> extends infer Id extends RouteId
+				? RouteParams<Id> extends Record<string, never>
+					? [route: T]
+					: [route: T, params: RouteParams<Id>]
+				: [never]
+			: [pathname: T];
+export type RouteMatch = { [Id in RouteId]: { id: Id; params: RouteParams<Id> } }[RouteId];
+export interface ManifestPath<Path extends string = string> {
+	path: Path;
+}
+type Only<Id extends string, Other extends string> = string extends Id
+	? string
+	: Exclude<Id, Other>;
+type Both<Id extends string, Other extends string> = string extends Id
+	? string
+	: Extract<Id, Other>;
+export type ManifestRoute =
+	| { id: Only<PageRouteId, EndpointRouteId>; page: true; endpoint: false }
+	| { id: Only<EndpointRouteId, PageRouteId>; page: false; endpoint: true }
+	| { id: Both<PageRouteId, EndpointRouteId>; page: true; endpoint: true };

package/src/types/remote-form.ts

@@ -0,0 +1,56 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type {
+	FieldContainer,
+	FieldIssues,
+	IsOpenShape,
+	OpenFields,
+	RemoteFormFields,
+	RemoteFormInput
+} from './fields.ts';
+import type { UpdatingPromise } from './remote.ts';
+import type { IsAny, MaybePromise, UnionKeys, UnionValue } from './value.ts';
+
+export type RootFields<Input, Original = Input> =
+	IsAny<Input> extends true
+		? OpenFields
+		: Input extends void
+			? FieldIssues
+			: IsOpenShape<Input> extends true
+				? OpenFields
+				: FieldContainer<Original> & {
+						[K in UnionKeys<Original>]-?: RemoteFormFields<UnionValue<Original, K>>;
+					};
+export type FormId<Input> = Input extends { id: infer Id }
+	? Id extends string | number
+		? Id
+		: string | number
+	: string | number;
+export interface FormAttributes {
+	[attachment: symbol]: (element: HTMLFormElement) => void;
+	method: 'POST';
+	action: string;
+}
+export interface FormValidationOptions {
+	all?: boolean;
+	preflightOnly?: boolean;
+}
+export type RemoteForm<Input extends RemoteFormInput | void, Output> = FormAttributes & {
+	readonly element: HTMLFormElement | null;
+	submit(): UpdatingPromise<boolean>;
+	enhance(callback: RemoteFormEnhanceCallback<Input, Output>): FormAttributes;
+	for(id: FormId<Input>): Omit<RemoteForm<Input, Output>, 'for'>;
+	preflight(schema: StandardSchemaV1<Input, any>): RemoteForm<Input, Output>;
+	validate(options?: FormValidationOptions): Promise<void>;
+	readonly result: Output | undefined;
+	readonly pending: number;
+	readonly submitted: boolean;
+	fields: RootFields<Input>;
+};
+export type RemoteFormEnhanceInstance<
+	Input extends RemoteFormInput | void = RemoteFormInput | void,
+	Output = any
+> = Omit<RemoteForm<Input, Output>, 'enhance' | 'element'> & { readonly element: HTMLFormElement };
+export type RemoteFormEnhanceCallback<
+	Input extends RemoteFormInput | void = RemoteFormInput | void,
+	Output = any
+> = (form: RemoteFormEnhanceInstance<Input, Output>) => MaybePromise<void>;