@vigla/kit 0.0.0-stage → 0.1.0

package/src/types/config.ts

@@ -0,0 +1,132 @@
+/// <reference path="../../types/index.d.ts" preserve="true" />
+import type { Options, PluginFactory } from '@vigla/vite-plugin';
+import type { Plugin } from 'vite';
+import type { Adapter } from './builder.ts';
+import type { CspConfig } from './csp.ts';
+import type { Identity } from './identity.ts';
+
+export interface CsrfConfig {
+	trustedOrigins?: string[];
+}
+export interface EnvironmentConfig {
+	dir?: string;
+}
+export interface HookFiles {
+	client?: string;
+	server?: string;
+	universal?: string;
+}
+export interface ProjectFiles {
+	src?: string;
+	assets?: string;
+	hooks?: HookFiles;
+	params?: string;
+	routes?: string;
+	serviceWorker?: string;
+	appTemplate?: string;
+	errorTemplate?: string;
+}
+export interface OutputConfig {
+	linkHeaderPreload?: boolean;
+	bundleStrategy?: 'split' | 'single' | 'inline';
+}
+export interface PathsConfig {
+	assets?: '' | `http://${string}` | `https://${string}`;
+	base?: '' | `/${string}`;
+	origin?: string;
+	relative?: boolean;
+}
+export interface PrerenderHttpError {
+	status: number;
+	path: string;
+	referrer: string | null;
+	referenceType: 'linked' | 'fetched';
+	message: string;
+}
+export interface PrerenderMissingId {
+	path: string;
+	id: string;
+	referrers: string[];
+	message: string;
+}
+export interface PrerenderEntryMismatch {
+	generatedFromId: string;
+	entry: string;
+	matchedId: string;
+	message: string;
+}
+export interface PrerenderUnseenRoutes {
+	routes: string[];
+	message: string;
+}
+export interface PrerenderInvalidUrl {
+	href: string;
+	referrer: string | null;
+	message: string;
+}
+export type PrerenderPolicy<T> = 'fail' | 'warn' | 'ignore' | ((details: T) => void);
+export interface PrerenderConfig {
+	concurrency?: number;
+	crawl?: boolean;
+	entries?: ('*' | `/${string}`)[];
+	handleHttpError?: PrerenderPolicy<PrerenderHttpError>;
+	handleMissingId?: PrerenderPolicy<PrerenderMissingId>;
+	handleEntryGeneratorMismatch?: PrerenderPolicy<PrerenderEntryMismatch>;
+	handleUnseenRoutes?: PrerenderPolicy<PrerenderUnseenRoutes>;
+	handleInvalidUrl?: PrerenderPolicy<PrerenderInvalidUrl>;
+}
+export interface RouterConfig {
+	type?: 'pathname' | 'hash';
+	resolution?: 'client' | 'server';
+}
+export type ServiceWorkerConfig =
+	| { register: true; options?: RegistrationOptions }
+	| { register?: false };
+export interface TracingConfig {
+	server?: boolean;
+}
+export interface TypescriptConfig {
+	config?: (config: Record<string, any>) => Record<string, any> | void;
+}
+export interface VersionConfig {
+	name?: string;
+	pollInterval?: number;
+}
+export type ExperimentalConfig<O extends object = Options> = (O extends {
+	experimental?: infer E;
+}
+	? NonNullable<E>
+	: {}) & {
+	remoteFunctions?: boolean;
+	forkPreloads?: boolean;
+};
+export interface FrameworkConfig {
+	adapter?: Adapter;
+	alias?: Record<string, string>;
+	appDir?: string;
+	csp?: CspConfig;
+	csrf?: CsrfConfig;
+	embedded?: boolean;
+	env?: EnvironmentConfig;
+	files?: ProjectFiles;
+	inlineStyleThreshold?: number;
+	moduleExtensions?: string[];
+	outDir?: string;
+	output?: OutputConfig;
+	paths?: PathsConfig;
+	prerender?: PrerenderConfig;
+	router?: RouterConfig;
+	serviceWorker?: ServiceWorkerConfig;
+	tracing?: TracingConfig;
+	typescript?: TypescriptConfig;
+	version?: VersionConfig;
+}
+export type Config<O extends object = Options> = Omit<O, 'experimental' | keyof FrameworkConfig> &
+	FrameworkConfig & { experimental?: ExperimentalConfig<O> };
+export type Framework<O extends object = Options> = (config?: Config<O>) => Promise<Plugin[]>;
+export type { Identity, Links } from './identity.ts';
+export declare function createKit<O extends object>(
+	identity: Identity,
+	factory: PluginFactory<O>
+): Framework<O>;
+export declare const kit: Framework;

package/src/types/csp.ts

@@ -0,0 +1,83 @@
+export type CspAction =
+	| 'strict-dynamic'
+	| 'report-sample'
+	| 'report-sha256'
+	| 'report-sha384'
+	| 'report-sha512';
+export type CspKeyword =
+	| 'self'
+	| 'unsafe-eval'
+	| 'unsafe-hashes'
+	| 'unsafe-inline'
+	| 'unsafe-allow-redirects'
+	| 'unsafe-webtransport-hashes'
+	| 'wasm-unsafe-eval'
+	| 'trusted-types-eval'
+	| 'none';
+export type CspHash = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
+export type CspScheme = `${string}:` & {};
+export type CspHost =
+	`${`${string}://` | ''}${`${string}.${string}` | 'localhost'}${`:${number}` | '' | ':*'}`;
+export type CspSource = CspHost | CspScheme | CspHash | CspKeyword;
+export type SandboxPermission =
+	| 'allow-downloads-without-user-activation'
+	| 'allow-forms'
+	| 'allow-modals'
+	| 'allow-orientation-lock'
+	| 'allow-pointer-lock'
+	| 'allow-popups'
+	| 'allow-popups-to-escape-sandbox'
+	| 'allow-presentation'
+	| 'allow-same-origin'
+	| 'allow-scripts'
+	| 'allow-storage-access-by-user-activation'
+	| 'allow-top-navigation'
+	| 'allow-top-navigation-by-user-activation';
+export type ReferrerPolicy =
+	| 'no-referrer'
+	| 'no-referrer-when-downgrade'
+	| 'origin'
+	| 'origin-when-cross-origin'
+	| 'same-origin'
+	| 'strict-origin'
+	| 'strict-origin-when-cross-origin'
+	| 'unsafe-url'
+	| 'none';
+export interface CspDirectives {
+	'child-src'?: CspSource[];
+	'default-src'?: (CspSource | CspAction)[];
+	'frame-src'?: CspSource[];
+	'worker-src'?: CspSource[];
+	'connect-src'?: CspSource[];
+	'font-src'?: CspSource[];
+	'img-src'?: CspSource[];
+	'manifest-src'?: CspSource[];
+	'media-src'?: CspSource[];
+	'object-src'?: CspSource[];
+	'prefetch-src'?: CspSource[];
+	'script-src'?: (CspSource | CspAction)[];
+	'script-src-elem'?: CspSource[];
+	'script-src-attr'?: CspSource[];
+	'style-src'?: (CspSource | CspAction)[];
+	'style-src-elem'?: CspSource[];
+	'style-src-attr'?: CspSource[];
+	'base-uri'?: (CspSource | CspAction)[];
+	sandbox?: SandboxPermission[];
+	'form-action'?: (CspSource | CspAction)[];
+	'frame-ancestors'?: (CspHost | CspScheme | 'self' | 'none')[];
+	'navigate-to'?: (CspSource | CspAction)[];
+	'report-uri'?: string[];
+	'report-to'?: string[];
+	'require-trusted-types-for'?: 'script'[];
+	'trusted-types'?: string[];
+	'upgrade-insecure-requests'?: boolean;
+	'require-sri-for'?: ('script' | 'style' | 'script style')[];
+	'block-all-mixed-content'?: boolean;
+	'plugin-types'?: (`${string}/${string}` | 'none')[];
+	referrer?: ReferrerPolicy[];
+}
+export interface CspConfig {
+	mode?: 'hash' | 'nonce' | 'auto';
+	directives?: CspDirectives;
+	reportOnly?: CspDirectives;
+}

package/src/types/env.ts

@@ -0,0 +1,20 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+export interface EnvVarConfig<T> {
+	public?: boolean;
+	static?: boolean;
+	schema?: StandardSchemaV1<string | undefined, T> | ((value: string | undefined) => T | undefined);
+	description?: string;
+}
+export type EnvVarEntry<Config extends EnvVarConfig<any>> =
+	Config['schema'] extends StandardSchemaV1<any, any>
+		? Config
+		: Config['schema'] extends (value: any) => infer Result
+			? Omit<Config, 'schema'> & { schema: StandardSchemaV1<string | undefined, Result> }
+			: Config;
+export type DefinedEnvVars<T extends Record<string, EnvVarConfig<any>>> = {
+	readonly [K in keyof T]: EnvVarEntry<T[K]>;
+};
+export declare function defineEnvVars<T extends Record<string, EnvVarConfig<any>>>(
+	variables: T
+): DefinedEnvVars<T>;

package/src/types/fields.ts

@@ -0,0 +1,177 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { DeepPartial, UnionKeys, UnionValue } from './value.ts';
+
+export interface ImageCoordinates {
+	x: number;
+	y: number;
+}
+export type IsImage<T> = T extends ImageCoordinates
+	? Exclude<keyof T, keyof ImageCoordinates> extends never
+		? true
+		: false
+	: false;
+export type IsOpenShape<T> = unknown extends T ? true : string extends keyof T ? true : false;
+export interface InputValues {
+	text: string;
+	email: string;
+	password: string;
+	url: string;
+	tel: string;
+	search: string;
+	number: number;
+	range: number;
+	date: string;
+	'datetime-local': string;
+	time: string;
+	month: string;
+	week: string;
+	color: string;
+	checkbox: boolean | string[];
+	radio: string;
+	file: File;
+	hidden: string | number | boolean;
+	submit: string | number | boolean;
+	button: string;
+	reset: string;
+	image: ImageCoordinates;
+	select: string;
+	'select multiple': string[];
+	'file multiple': File[];
+}
+export type RemoteFormFieldType<Value> = {
+	[Type in keyof InputValues]: Value extends InputValues[Type] ? Type : never;
+}[keyof InputValues];
+export interface FieldAttributes {
+	name: string;
+	'aria-invalid': boolean | 'false' | 'true' | undefined;
+}
+export interface CheckedAttributes<Type> extends FieldAttributes {
+	type: Type;
+	value?: string;
+	checked: boolean;
+	readonly defaultChecked?: boolean;
+}
+export interface ImageAttributes extends FieldAttributes {
+	type: 'image';
+}
+export interface FileAttributes extends FieldAttributes {
+	type: 'file';
+	files: FileList | null;
+}
+export interface SelectAttributes extends FieldAttributes {
+	value: string;
+}
+export interface MultiSelectAttributes extends FieldAttributes {
+	multiple: true;
+	value: string[];
+}
+export interface TextAttributes<Value> extends FieldAttributes {
+	value: Value extends string ? string : string | number;
+	readonly defaultValue?: Value extends string ? string : string | number;
+}
+export interface ValueAttributes<Type> extends FieldAttributes {
+	type: Type;
+	value: string | number;
+	readonly defaultValue?: string | number;
+}
+export type InputAttributes<Type extends keyof InputValues, Value> = Type extends
+	| 'checkbox'
+	| 'radio'
+	? CheckedAttributes<Type>
+	: Type extends 'image'
+		? ImageAttributes
+		: Type extends 'file'
+			? FileAttributes
+			: Type extends 'select'
+				? SelectAttributes
+				: Type extends 'select multiple'
+					? MultiSelectAttributes
+					: Type extends 'text'
+						? TextAttributes<Value>
+						: ValueAttributes<Type>;
+export interface RemoteFormIssue {
+	message: string;
+	path: (string | number)[];
+}
+export interface FieldIssues {
+	issues(): RemoteFormIssue[] | undefined;
+	allIssues(): RemoteFormIssue[] | undefined;
+}
+export interface FieldMethods<Value> {
+	value(): DeepPartial<Value>;
+	set(value: DeepPartial<Value>): DeepPartial<Value>;
+	touched(): boolean;
+	dirty(): boolean;
+	issues(): RemoteFormIssue[] | undefined;
+}
+export interface FieldContainer<Value> extends FieldMethods<Value> {
+	allIssues(): RemoteFormIssue[] | undefined;
+}
+export type RemoteFormFieldValue =
+	| string
+	| string[]
+	| number
+	| boolean
+	| File
+	| File[]
+	| ImageCoordinates;
+export type FieldArgs<Type extends keyof InputValues, Value> = Type extends 'checkbox'
+	? Value extends string[]
+		? [type: Type, value: Value[number] | (string & {}), checked?: boolean]
+		: Value extends boolean
+			? [type: Type, value?: boolean]
+			: [type: Type, value?: Value]
+	: Type extends 'image' | 'file' | 'file multiple'
+		? [type: Type]
+		: Type extends 'submit' | 'hidden'
+			? [type: Type, value: Value extends string ? Value | (string & {}) : Value]
+			: Type extends 'radio'
+				? [type: Type, value: Value | (string & {}), checked?: boolean]
+				: [type: Type, value?: Value];
+type WidenText<T> = T extends string ? string : T;
+export type RemoteFormField<Value extends RemoteFormFieldValue> = FieldMethods<Value> & {
+	as<Type extends RemoteFormFieldType<Value>>(
+		...args: FieldArgs<Type, Value>
+	): InputAttributes<Type, WidenText<Value>>;
+};
+export type UnknownField<Value> = FieldContainer<Value> & {
+	as<Type extends RemoteFormFieldType<Value>>(
+		...args: FieldArgs<Type, Value>
+	): InputAttributes<Type, Value>;
+} & { [key: string | number]: UnknownField<any> };
+export type OpenFields = FieldContainer<any> & { [key: string | number]: UnknownField<any> };
+type ObjectFields<T> = { [K in UnionKeys<T>]-?: RemoteFormFields<UnionValue<T, K>> };
+export type RemoteFormFields<Value> =
+	IsOpenShape<Value> extends true
+		? OpenFields
+		: NonNullable<Value> extends string | number | boolean | File
+			? RemoteFormField<NonNullable<Value>>
+			: IsImage<NonNullable<Value>> extends true
+				? RemoteFormField<NonNullable<Value> & ImageCoordinates> &
+						Pick<FieldIssues, 'allIssues'> &
+						ObjectFields<Value>
+				: [NonNullable<Value>] extends [string[] | File[]]
+					? RemoteFormField<NonNullable<Value>> & {
+							[index: number]: RemoteFormField<NonNullable<Value>[number]>;
+						}
+					: [NonNullable<Value>] extends [Array<infer Element>]
+						? FieldContainer<NonNullable<Value>> & { [index: number]: RemoteFormFields<Element> }
+						: FieldContainer<Value> & ObjectFields<Value>;
+export type RemoteFormInvalidField<Value> =
+	IsOpenShape<Value> extends true
+		? Record<string | number, any>
+		: NonNullable<Value> extends string | number | boolean | File
+			? (message: string) => StandardSchemaV1.Issue
+			: NonNullable<Value> extends Array<infer Element>
+				? { [index: number]: RemoteFormInvalidField<Element> } & ((
+						message: string
+					) => StandardSchemaV1.Issue)
+				: NonNullable<Value> extends RemoteFormInput
+					? { [K in keyof Value]-?: RemoteFormInvalidField<Value[K]> } & ((
+							message: string
+						) => StandardSchemaV1.Issue)
+					: Record<string, never>;
+export type FormValue = string | number | boolean | File | RemoteFormInput;
+export interface RemoteFormInput {
+	[key: string]: FormValue | FormValue[] | undefined;
+}

package/src/types/forms.ts

@@ -0,0 +1,44 @@
+import type { MaybePromise } from './value.ts';
+
+export type ActionResult<
+	Success extends Record<string, unknown> | undefined = Record<string, any>,
+	Failure extends Record<string, unknown> | undefined = Record<string, any>
+> =
+	| { type: 'success'; status: number; data?: Success; location: string }
+	| { type: 'failure'; status: number; data?: Failure; location: string }
+	| { type: 'redirect'; status: number; location: string }
+	| { type: 'error'; status?: number; error: App.Error; location?: string };
+export interface FormUpdateOptions {
+	reset?: boolean;
+	refreshAll?: boolean;
+	navigate?: boolean;
+}
+export interface SubmitInput {
+	action: URL;
+	formData: FormData;
+	formElement: HTMLFormElement;
+	controller: AbortController;
+	submitter: HTMLElement | null;
+	cancel(): void;
+}
+export interface SubmitResult<
+	Success extends Record<string, unknown> | undefined,
+	Failure extends Record<string, unknown> | undefined,
+	Update extends FormUpdateOptions = FormUpdateOptions
+> {
+	formData: FormData;
+	formElement: HTMLFormElement;
+	action: URL;
+	result: ActionResult<Success, Failure>;
+	update(options?: Update): Promise<void>;
+}
+export type SubmitFunction<
+	Success extends Record<string, unknown> | undefined = Record<string, any>,
+	Failure extends Record<string, unknown> | undefined = Record<string, any>,
+	Update extends FormUpdateOptions = FormUpdateOptions
+> = (
+	input: SubmitInput
+) => MaybePromise<void | ((result: SubmitResult<Success, Failure, Update>) => MaybePromise<void>)>;
+export interface Enhancement {
+	destroy(): void;
+}

package/src/types/hooks.ts

@@ -0,0 +1,56 @@
+/// <reference path="../../types/index.d.ts" preserve="true" />
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ErrorBody, ErrorReturn } from './outcomes.ts';
+import type { NavigationEvent, RequestEvent } from './request.ts';
+import type { MaybePromise } from './value.ts';
+
+export interface PageChunk {
+	html: string;
+	done: boolean;
+}
+export type PreloadFile =
+	| { type: 'css' | 'js' | 'asset'; path: string }
+	| { type: 'font'; path: string; filename: string };
+export interface ResolveOptions {
+	transformPageChunk?: (chunk: PageChunk) => MaybePromise<string | undefined>;
+	filterSerializedResponseHeaders?: (name: string, value: string) => boolean;
+	preload?: (file: PreloadFile) => boolean;
+}
+export type Resolve = (event: RequestEvent, options?: ResolveOptions) => Promise<Response>;
+export interface HandleInput {
+	event: RequestEvent;
+	resolve: Resolve;
+}
+export type Handle = (input: HandleInput) => MaybePromise<Response>;
+type ErrorKinds = { app: App.Error; framework: ErrorBody; unknown: unknown };
+export type CaughtError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
+	| {
+			[K in keyof ErrorKinds]: { kind: K; error: ErrorKinds[K]; issues?: undefined };
+	  }[keyof ErrorKinds]
+	| { kind: 'validation'; error: ErrorBody; issues: Issue[] };
+export type ClientCaughtError = Exclude<CaughtError, { kind: 'validation' }>;
+export type HandleServerError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> = (
+	input: CaughtError<Issue> & { event: RequestEvent }
+) => MaybePromise<ErrorReturn>;
+export type HandleClientError = (
+	input: ClientCaughtError & { event: NavigationEvent }
+) => MaybePromise<ErrorReturn>;
+export interface FetchInput {
+	event: RequestEvent;
+	request: Request;
+	fetch: typeof fetch;
+}
+export type HandleFetch = (input: FetchInput) => MaybePromise<Response>;
+export type ServerInit = () => MaybePromise<void>;
+export type ClientInit = () => MaybePromise<void>;
+export interface RerouteEvent {
+	url: URL;
+	fetch: typeof fetch;
+}
+export type Reroute = (event: RerouteEvent) => MaybePromise<void | string>;
+export interface Transporter<T = any, Encoded = any> {
+	encode(value: T): false | Encoded;
+	decode(value: Encoded): T;
+}
+export type Transport = Record<string, Transporter>;
+export declare function sequence(...handlers: Handle[]): Handle;

package/src/types/identity.ts

@@ -0,0 +1,28 @@
+export interface Links {
+	formFields?: string;
+	formValidation?: string;
+	prerender?: string;
+	prerenderConflicts?: string;
+	namedActions?: string;
+	enhance?: string;
+	transport?: string;
+	handle?: string;
+	observability?: string;
+	fetch?: string;
+	adapters?: string;
+}
+
+export interface Identity {
+	name: string;
+	product: string;
+	framework?: string;
+	plugin: string;
+	command: string;
+	outDir: string;
+	assets: string;
+	announcer: string;
+	packages: string[];
+	diagnostics?: string;
+	links?: Links;
+	replacedLinkOptions?: Record<string, string>;
+}

package/src/types/index.ts

@@ -0,0 +1,66 @@
+/// <reference path="../../types/index.d.ts" preserve="true" />
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type {
+	ActionFailure,
+	ErrorFunction,
+	HttpError,
+	NormalizedUrl,
+	Redirect,
+	RedirectOptions,
+	RedirectStatus,
+	ValidationError
+} from './outcomes.ts';
+
+export type { Identity, Links } from './identity.ts';
+export type {
+	Adapter,
+	AdapterViteConfig,
+	Builder,
+	Emulator,
+	PrerenderOption,
+	RouteDefinition
+} from './builder.ts';
+export type {
+	Action,
+	Actions,
+	Cookies,
+	Load,
+	LoadEvent,
+	NavigationEvent,
+	RequestEvent,
+	RequestHandler,
+	Server,
+	ServerInitOptions,
+	ServerLoad,
+	ServerLoadEvent,
+	Snapshot
+} from './request.ts';
+export type {
+	ActionFailure,
+	AwaitedActions,
+	HttpError,
+	LoadProperties,
+	Redirect,
+	ValidationError
+} from './outcomes.ts';
+
+export declare const error: ErrorFunction;
+export declare function isHttpError<Status extends number>(
+	value: unknown,
+	status?: Status
+): value is HttpError & { status: Status extends undefined ? never : Status };
+export declare function redirect(
+	status: RedirectStatus | (number & {}),
+	location: string | URL,
+	options?: RedirectOptions
+): never;
+export declare function isRedirect(value: unknown): value is Redirect;
+export declare function json(data: any, init?: ResponseInit): Response;
+export declare function text(body: string, init?: ResponseInit): Response;
+export declare function fail(status: number): ActionFailure<undefined>;
+export declare function fail<T = undefined>(status: number, data: T): ActionFailure<T>;
+export declare function isActionFailure(value: unknown): value is ActionFailure<undefined>;
+export declare function invalid(...issues: (StandardSchemaV1.Issue | string)[]): never;
+export declare function isValidationError(value: unknown): value is ValidationError;
+export declare function normalizeUrl(url: URL | string): NormalizedUrl;
+export declare const VERSION: string;