@vigla/kit 0.0.0-stage → 0.1.0

package/src/build/worker.ts

@@ -0,0 +1,152 @@
+import { fork } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { PrerenderPolicy } from '../types/config.ts';
+import type { BuildContext, Analysis } from './types.ts';
+import { BuildMessages } from './messages.ts';
+import type {
+	AnalysisJob,
+	FallbackJob,
+	PolicyIssue,
+	PrerenderJob,
+	PrerenderResult,
+	WorkerJob,
+	WorkerMessage,
+	WorkerPlatform,
+	WorkerValue
+} from './jobs.ts';
+
+function platform(context: BuildContext): WorkerPlatform {
+	return {
+		identity: context.identity,
+		directory: `${context.config.outDir}/output`,
+		assets: context.config.files.assets,
+		origin: context.config.paths.origin || 'http://prerender.invalid',
+		environment: context.environment
+	};
+}
+async function applyPolicy<T extends { message: string }>(
+	name: PolicyIssue['kind'],
+	policy: PrerenderPolicy<T> | undefined,
+	details: T,
+	context: BuildContext
+): Promise<void> {
+	if (typeof policy === 'function') {
+		await policy(details);
+		return;
+	}
+	if (policy === 'ignore') return;
+	if (policy === 'warn') {
+		context.log.warn(details.message);
+		return;
+	}
+	throw new Error(
+		policy === 'fail'
+			? details.message
+			: `${details.message}\n${new BuildMessages(context.diagnostics).prerender_policy_hint(name)}`
+	);
+}
+async function policy(issue: PolicyIssue, context: BuildContext): Promise<void> {
+	const settings = context.config.prerender;
+	switch (issue.kind) {
+		case 'handleHttpError':
+			await applyPolicy(issue.kind, settings.handleHttpError, issue.details, context);
+			break;
+		case 'handleMissingId':
+			await applyPolicy(issue.kind, settings.handleMissingId, issue.details, context);
+			break;
+		case 'handleEntryGeneratorMismatch':
+			await applyPolicy(issue.kind, settings.handleEntryGeneratorMismatch, issue.details, context);
+			break;
+		case 'handleUnseenRoutes':
+			await applyPolicy(issue.kind, settings.handleUnseenRoutes, issue.details, context);
+			break;
+		case 'handleInvalidUrl':
+			await applyPolicy(issue.kind, settings.handleInvalidUrl, issue.details, context);
+			break;
+	}
+}
+function run(job: AnalysisJob, context: BuildContext): Promise<Analysis>;
+function run(job: FallbackJob, context: BuildContext): Promise<string>;
+function run(job: PrerenderJob, context: BuildContext): Promise<PrerenderResult>;
+function run(job: WorkerJob, context: BuildContext): Promise<WorkerValue> {
+	return new Promise((resolve, reject) => {
+		const child = fork(
+			fileURLToPath(new URL(`./worker-entry${path.extname(import.meta.url)}`, import.meta.url)),
+			[],
+			{
+				serialization: 'advanced',
+				stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+			}
+		);
+		let answered = false;
+		child.once('error', reject);
+		child.once('exit', (code, signal) => {
+			if (!answered) reject(new Error(`Build worker exited before answering (${signal ?? code})`));
+		});
+		child.on('message', async (message: WorkerMessage) => {
+			if (answered) return;
+			if (message.kind === 'policy') {
+				try {
+					await policy(message.issue, context);
+					if (!answered) child.send({ id: message.id });
+				} catch (error) {
+					answered = true;
+					reject(error);
+					child.kill();
+				}
+				return;
+			}
+			answered = true;
+			if (message.kind === 'error') {
+				const error = new Error(message.error.message);
+				error.stack = message.error.stack;
+				reject(error);
+			} else resolve(message.value);
+		});
+		child.send(job);
+	});
+}
+export function analyseBuild(context: BuildContext): Promise<Analysis> {
+	return run(
+		{
+			...platform(context),
+			kind: 'analyse',
+			hash: context.config.router.type === 'hash',
+			sources: {
+				params: context.tree.params ?? null,
+				extension: context.config.extensions[0] ?? '',
+				endpoints: Object.fromEntries(
+					context.tree.routes.flatMap((route) =>
+						route.endpoint ? [[route.id, route.endpoint.file.split('/').pop()!]] : []
+					)
+				)
+			}
+		},
+		context
+	);
+}
+export function renderFallback(context: BuildContext): Promise<string> {
+	return run({ ...platform(context), kind: 'fallback' }, context);
+}
+export function prerenderBuild(
+	context: BuildContext,
+	configFile?: string
+): Promise<PrerenderResult> {
+	return run(
+		{
+			...platform(context),
+			kind: 'prerender',
+			root: context.root,
+			mode: context.mode,
+			configFile,
+			analysis: context.analysis,
+			base: context.config.paths.base,
+			hash: context.config.router.type === 'hash',
+			entries: context.config.prerender.entries,
+			crawl: context.config.prerender.crawl,
+			concurrency: context.config.prerender.concurrency
+		},
+		context
+	);
+}

package/src/client/actions.ts

@@ -0,0 +1,69 @@
+import type { ActionResult } from '../types/forms.ts';
+import type { Client } from './client.ts';
+import type { DataRedirectNode } from '../types/internal/data.ts';
+import type { Loaded } from './load.ts';
+
+export class Actions {
+	readonly #client: Client;
+	constructor(client: Client) {
+		this.#client = client;
+	}
+
+	async result(page: Loaded, action: ActionResult): Promise<Loaded | DataRedirectNode> {
+		if (action.type === 'error')
+			return this.#client.pages.failure(
+				page,
+				page.branch,
+				page.route.layouts.length + 1,
+				action.error
+			);
+		return this.settled(page, action);
+	}
+
+	settled(page: Loaded, action: ActionResult): Loaded {
+		if (action.type === 'success' || action.type === 'failure')
+			return { ...page, status: action.status, form: action.data ?? null };
+		return page;
+	}
+
+	async apply(action: ActionResult): Promise<void> {
+		const client = this.#client;
+		await client.ready.promise;
+		if (action.type === 'redirect') return client.goto(action.location, { refreshAll: true });
+		if (!client.current) return;
+		const generation = client.generation;
+		const result = await this.result(client.current, action);
+		if (result.type === 'redirect') return client.goto(result.location, { refreshAll: true });
+		const apply = await client.view.prepare(result, client.state.page.state);
+		if (generation !== client.generation) return;
+		apply();
+		client.current = result;
+		await client.view.settle();
+		if (action.type === 'success') client.restoration.focus(result.url);
+	}
+
+	async submit(url: URL, action: ActionResult, refresh: boolean): Promise<void> {
+		const client = this.#client;
+		if (action.type === 'redirect') return this.apply(action);
+		for (const key of [...url.searchParams.keys()])
+			if (key.startsWith('/')) url.searchParams.delete(key);
+		const current = client.current?.url;
+		const keys = new Set([...url.searchParams.keys(), ...(current?.searchParams.keys() ?? [])]);
+		const same =
+			current &&
+			url.origin === current.origin &&
+			url.pathname === current.pathname &&
+			[...keys].every((key) => {
+				const before = current.searchParams.getAll(key).sort();
+				const after = url.searchParams.getAll(key).sort();
+				return (
+					before.length === after.length && before.every((value, index) => value === after[index])
+				);
+			});
+		if (same) {
+			if (refresh) await client.invalidate(undefined, true);
+			return this.apply(action);
+		}
+		return client.navigate(url, { type: 'form', action, refreshAll: refresh });
+	}
+}

package/src/client/chunks.ts

@@ -0,0 +1,75 @@
+import type { Owner } from 'vigla';
+import type { ChunkDecoder, ClientApp } from '../types/internal/client.ts';
+
+interface Deferred {
+	promise: Promise<unknown>;
+	resolve(value: unknown): void;
+	reject(error: unknown): void;
+	used: boolean;
+	settled: boolean;
+}
+
+export class Chunks {
+	readonly #pending = new Map<number, Deferred>();
+	readonly #queued = new Map<number, ChunkDecoder>();
+	#app: ClientApp | undefined;
+	#owner: Owner | undefined;
+	#disposed = false;
+
+	#record(id: number): Deferred {
+		let record = this.#pending.get(id);
+		if (!record) {
+			record = { ...Promise.withResolvers<unknown>(), used: false, settled: false };
+			void record.promise.catch(() => {});
+			this.#pending.set(id, record);
+		}
+		return record;
+	}
+
+	#release(id: number, record: Deferred): void {
+		if (record.used && record.settled)
+			queueMicrotask(() => {
+				if (this.#pending.get(id) === record) this.#pending.delete(id);
+			});
+	}
+
+	defer(id: number): Promise<unknown> {
+		const record = this.#record(id);
+		record.used = true;
+		this.#release(id, record);
+		return record.promise;
+	}
+
+	resolve(id: number, decode: ChunkDecoder): void {
+		if (this.#disposed) return;
+		if (!this.#owner || !this.#app) {
+			this.#queued.set(id, decode);
+			return;
+		}
+		const record = this.#record(id);
+		try {
+			const [data, error] = this.#owner.run(() => decode(this.#app!));
+			if (error !== undefined) record.reject(error);
+			else record.resolve(data);
+		} catch (error) {
+			record.reject(error);
+		}
+		record.settled = true;
+		this.#release(id, record);
+	}
+
+	bind(app: ClientApp, owner: Owner): void {
+		this.#app = app;
+		this.#owner = owner;
+		for (const [id, decode] of this.#queued) this.resolve(id, decode);
+		this.#queued.clear();
+	}
+
+	dispose(): void {
+		this.#disposed = true;
+		for (const record of this.#pending.values())
+			record.reject(new Error('The tab owner was disposed'));
+		this.#pending.clear();
+		this.#queued.clear();
+	}
+}