@vigla/kit 0.0.0-stage → 0.1.1

package/src/types/internal/client.ts

@@ -0,0 +1,126 @@
+import type { Component, Exports } from 'vigla';
+import type { Format } from 'vigla/compiler';
+import type { ClientInit, HandleClientError, Reroute, Transport } from '../hooks.ts';
+import type { Load } from '../request.ts';
+import type { Page } from '../state.ts';
+import type { ParamMatcher, ParamValue } from '../params.ts';
+import type { DataNode, TrailingSlash } from './data.ts';
+
+export type MatchedParams = Record<string, ParamValue>;
+
+export interface UniversalNode {
+	load?: Load;
+	trailingSlash?: TrailingSlash;
+	ssr?: boolean;
+	csr?: boolean;
+	prerender?: boolean | 'auto';
+}
+
+export interface ClientNode {
+	component: Component<any, any>;
+	universal?: UniversalNode;
+	imports?: string[];
+	stylesheets?: string[];
+}
+
+export type NodeLoader = () => Promise<ClientNode>;
+export type RouteDictionary = Record<
+	string,
+	[leaf: number, layouts: Array<number | undefined>, errors?: Array<number | undefined>]
+>;
+export type NodeReference = [hasServerLoad: boolean, node: number];
+
+export interface ServerRoute {
+	id: string;
+	errors: Array<number | undefined>;
+	layouts: Array<NodeReference | undefined>;
+	leaf: NodeReference;
+	nodes: Record<string, NodeLoader>;
+}
+
+export interface ClientHooks {
+	init?: ClientInit;
+	handleError?: HandleClientError;
+	reroute?: Reroute;
+	transport?: Transport;
+}
+
+export interface RenderNode {
+	component: Component<any, any>;
+	error?: Component<any, any>;
+	data: Record<string, any>;
+	child: RenderNode | null;
+}
+
+export interface Restorer {
+	capture(navigation: number, components: Exports[]): void;
+	restore(navigation: number, components: Exports[]): void;
+	prune(navigation: number): void;
+	persist(): void;
+}
+
+export interface RootProps extends Record<string, unknown> {
+	page: Page<MatchedParams>;
+	components: Exports[];
+	onerror: (error: unknown, reset: () => void) => void;
+	tree: RenderNode;
+	form: Record<string, any> | null;
+	error: App.Error | null;
+}
+
+export interface RenderedLocation {
+	pathname: string;
+	search?: string;
+}
+
+export interface ClientPayload {
+	rendered?: RenderedLocation;
+	hash?: boolean;
+	base?: string;
+	assets?: string;
+	app_dir?: string;
+	app_path?: string;
+	env?: Record<string, unknown>;
+	version?: string;
+	version_poll_interval?: number;
+	embedded?: boolean;
+}
+
+export interface ClientApp {
+	global: string;
+	nodes: NodeLoader[];
+	serverLoads: number[];
+	dictionary: RouteDictionary;
+	matchers: Record<string, ParamMatcher>;
+	hooks: ClientHooks;
+	root: Component<RootProps, any>;
+	restorer?: () => Restorer;
+	format?: Format;
+	clientRouting?: boolean;
+	versionChecks?: boolean;
+	encoders: Record<string, (value: any) => false | any>;
+	decoders: Record<string, (value: any) => any>;
+	decode?: (type: string, value: any) => any;
+	errorTemplate?: () => Promise<(data: { status: number; message: string }) => string>;
+}
+
+export type Hydration = () => HydrationPayload;
+export type ChunkDecoder = (app: ClientApp) => [data?: unknown, error?: unknown];
+
+export interface ClientGlobal extends ClientPayload {
+	ready?: Promise<void>;
+	defer(id: number): Promise<unknown>;
+	resolve(id: number, decode: ChunkDecoder): void;
+}
+
+export interface HydrationPayload {
+	status?: number;
+	error: App.Error | null;
+	node_ids: number[];
+	params: MatchedParams;
+	route: { id: string | null };
+	server_route?: ServerRoute;
+	data: Array<DataNode | null>;
+	form: Record<string, any> | null;
+	remote?: Record<string, any>;
+}

package/src/types/internal/data.ts

@@ -0,0 +1,57 @@
+export type TrailingSlash = 'always' | 'never' | 'ignore';
+
+export interface SerializedUses {
+	dependencies?: string[];
+	params?: string[];
+	search_params?: string[];
+	parent?: 1;
+	route?: 1;
+	url?: 1;
+}
+
+export interface DataNode {
+	type: 'data';
+	data: Record<string, any> | null;
+	uses: SerializedUses;
+	slash?: TrailingSlash;
+}
+
+export interface DataSkippedNode {
+	type: 'skip';
+}
+
+export interface DataErrorNode {
+	type: 'error';
+	error: App.Error;
+	status?: number;
+}
+
+export interface DataRedirectNode {
+	type: 'redirect';
+	status: number;
+	location: string;
+}
+
+export interface DataChunkNode {
+	type: 'chunk';
+	id: number;
+	data?: any;
+	error?: any;
+}
+
+export interface EncodedDataNode {
+	type: 'data';
+	data: any;
+	uses: SerializedUses;
+	slash?: TrailingSlash;
+}
+
+export interface DataResponse {
+	type: 'data';
+	nodes: Array<DataNode | DataSkippedNode | DataErrorNode | null>;
+}
+
+export interface EncodedDataResponse {
+	type: 'data';
+	nodes: Array<EncodedDataNode | DataSkippedNode | DataErrorNode | null>;
+}

package/src/types/internal/remote.ts

@@ -0,0 +1,130 @@
+import type { RemoteForm } from '../remote-form.ts';
+import type { RemoteLiveQuery, RemoteQuery } from '../remote.ts';
+import type { MaybePromise } from '../value.ts';
+import type { RequestStore } from './server.ts';
+
+export interface RemoteNode {
+	v?: any;
+	e?: App.Error;
+}
+export interface RemoteData {
+	_?: any;
+	q?: Record<string, RemoteNode>;
+	l?: Record<string, RemoteNode>;
+	p?: Record<string, RemoteNode>;
+	f?: Record<string, RemoteNode>;
+	i?: string[];
+	r?: boolean;
+	redirect?: string;
+}
+export type RemoteResponse =
+	| { type: 'result'; data: string | null }
+	| { type: 'error'; error: App.Error }
+	| { type: 'redirect'; location: string };
+export type RemoteLiveResponse =
+	| { type: 'result'; result: string }
+	| { type: 'error'; error: App.Error }
+	| { type: 'redirect'; location: string };
+export interface BinaryFormMeta {
+	remote_refreshes?: string[];
+	validate_only?: boolean;
+}
+export interface InternalFormIssue {
+	name: string;
+	path: Array<string | number>;
+	message: string;
+	server?: boolean;
+}
+export interface RemoteFormResult {
+	submission?: boolean;
+	input?: Record<string, any>;
+	issues?: InternalFormIssue[];
+	result?: any;
+}
+
+export type RemoteValidator = (arg: any) => MaybePromise<any>;
+export type RemoteImplementation = (...args: any[]) => any;
+interface BaseInternals {
+	id: string;
+	name: string;
+	validate: RemoteValidator;
+	implementation: RemoteImplementation;
+}
+export interface RemoteQueryInternals extends BaseInternals {
+	type: 'query';
+	bind(payload: string, arg: any): RemoteQuery<any>;
+}
+export interface RemoteBatchInternals extends BaseInternals {
+	type: 'query_batch';
+	bind(payload: string, arg: any): RemoteQuery<any>;
+	run(args: any[]): Promise<RemoteBatchResult[]>;
+}
+export interface RemoteLiveInternals extends BaseInternals {
+	type: 'query_live';
+	bind(payload: string, arg: any): RemoteLiveQuery<any>;
+	run(store: RequestStore, arg: any): AsyncGenerator<any>;
+}
+export interface RemoteCommandInternals extends BaseInternals {
+	type: 'command';
+}
+export interface RemoteFormInternals extends BaseInternals {
+	type: 'form';
+	key?: string;
+	fn(
+		data: Record<string, any>,
+		meta: BinaryFormMeta,
+		formData: FormData | null
+	): Promise<RemoteFormResult | InternalFormIssue[]>;
+}
+export interface RemotePrerenderInternals extends BaseInternals {
+	type: 'prerender';
+	has_arg: boolean;
+	dynamic?: boolean;
+	inputs?: () => MaybePromise<any[]>;
+}
+export type RemoteReadInternals = RemoteQueryInternals | RemoteBatchInternals | RemoteLiveInternals;
+export type RemoteInternals =
+	| RemoteReadInternals
+	| RemoteCommandInternals
+	| RemoteFormInternals
+	| RemotePrerenderInternals;
+export interface RemoteExport {
+	readonly __: RemoteInternals;
+}
+export type RemoteFunction = ((arg?: any) => any) & RemoteExport;
+export type RemoteFormInstance = RemoteForm<any, any> & { readonly __: RemoteFormInternals };
+export type RemoteBatchResult = { type: 'result'; data: any } | { type: 'error'; error: App.Error };
+export interface RemoteRefresh {
+	internals: RemoteInternals;
+	read(): Promise<any>;
+}
+export interface RemoteResolver {
+	resolve(value: any): void;
+	reject(error: unknown): void;
+}
+export interface RemoteBatchEntry {
+	input(): MaybePromise<any>;
+	resolvers: RemoteResolver[];
+}
+export interface RemoteIterator {
+	subscribe(): AsyncIterableIterator<any>;
+}
+export interface RemoteSnapshot {
+	read(): RemoteNode | Promise<RemoteNode>;
+}
+export interface RemoteRequestState {
+	cache: Map<RemoteInternals, Map<string, Promise<any>>>;
+	forms: Map<string, RemoteFormInstance>;
+	formValues: Map<RemoteFormInternals, RemoteFormResult>;
+	batches: Map<RemoteBatchInternals, Map<string, RemoteBatchEntry>>;
+	live: Map<string, RemoteIterator>;
+	explicit: Map<string, RemoteRefresh>;
+	implicit: Map<string, RemoteRefresh>;
+	requested: Map<string, Set<string>>;
+	ignored: Set<string>;
+	hydration: Set<string>;
+	snapshots: Map<string, RemoteSnapshot>;
+	query: boolean;
+	prerender: boolean;
+	mutation: boolean;
+}

package/src/types/internal/routes.ts

@@ -0,0 +1,74 @@
+export interface RouteParam {
+	name: string;
+	matcher?: string;
+	optional: boolean;
+	rest: boolean;
+	chained: boolean;
+}
+
+export interface PageOptions {
+	ssr?: boolean;
+	csr?: boolean;
+	prerender?: boolean | 'auto';
+	trailingSlash?: 'always' | 'never' | 'ignore';
+	config?: unknown;
+	entries?: unknown;
+	load?: null;
+}
+
+export interface PageNode {
+	depth: number;
+	component?: string;
+	universal?: string;
+	server?: string;
+	parent: number | null;
+	options: PageOptions | null;
+}
+
+export interface PageBranch {
+	layouts: Array<number | undefined>;
+	errors: Array<number | undefined>;
+	leaf: number;
+}
+
+export interface Endpoint {
+	file: string;
+	options: PageOptions | null;
+}
+
+export interface Route {
+	id: string;
+	parent: string | null;
+	segment: string;
+	pattern: RegExp;
+	params: RouteParam[];
+	layout: number | null;
+	error: number | null;
+	leaf: number | null;
+	page: PageBranch | null;
+	endpoint: Endpoint | null;
+}
+
+export interface RouteAsset {
+	file: string;
+	type: string | null;
+}
+
+export interface RouteHooks {
+	client: string | null;
+	server: string | null;
+	universal: string | null;
+}
+
+export interface RouteTree {
+	assets: RouteAsset[];
+	hooks: RouteHooks;
+	params: string | null;
+	nodes: PageNode[];
+	routes: Route[];
+}
+
+export interface RoutePattern {
+	pattern: RegExp;
+	params: RouteParam[];
+}