@vigla/kit 0.0.0-stage → 0.1.1

package/src/build/instrument.ts

@@ -0,0 +1,56 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import type { InitializerOptions, InstrumentOptions } from '../types/builder.ts';
+import { copy, posix, specifier, write } from './files.ts';
+import type { BuildMessages } from './messages.ts';
+
+export function initializer(options: InitializerOptions, server: string): string {
+	const provider = path.join(options.outputDirectory, '__env.js');
+	write(provider, options.environment ?? 'export default process.env;');
+	const file = path.join(options.outputDirectory, '__env_init.js');
+	const environment = specifier(path.dirname(file), provider);
+	const target = specifier(
+		path.dirname(file),
+		path.join(options.serverDirectory ?? server, 'env.js')
+	);
+	write(
+		file,
+		`import env from ${JSON.stringify(environment)};\nimport { set_env } from ${JSON.stringify(target)};\nawait set_env(env);\n`
+	);
+	return file;
+}
+
+export function instrument(options: InstrumentOptions, e: BuildMessages): void {
+	for (const [kind, file] of [
+		['Instrumentation file', options.instrumentation],
+		['Entrypoint file', options.entrypoint],
+		['Instrumentation initializer', options.initializer]
+	]) {
+		if (!existsSync(file!)) e.adapter_instrumentation_file_missing({ kind: kind!, file: file! });
+	}
+	const directory = path.dirname(options.entrypoint);
+	const start = options.start ?? path.join(directory, 'start.js');
+	copy(options.entrypoint, start);
+	if (existsSync(options.entrypoint + '.map')) copy(options.entrypoint + '.map', start + '.map');
+	const paths = {
+		initializer: posix(path.relative(directory, options.initializer)),
+		instrumentation: posix(path.relative(directory, options.instrumentation)),
+		start: posix(path.relative(directory, start))
+	};
+	const module = options.module ?? { exports: ['default'] };
+	if ('generateText' in module) {
+		write(options.entrypoint, module.generateText(paths));
+		return;
+	}
+	const lines = [
+		`import ${JSON.stringify(specifier(directory, options.initializer))};`,
+		`await import(${JSON.stringify(specifier(directory, options.instrumentation))});`,
+		`const entry = await import(${JSON.stringify(specifier(directory, start))});`
+	];
+	module.exports.forEach((name, index) =>
+		lines.push(
+			`const value${index} = entry[${JSON.stringify(name)}]; export { value${index} as ${JSON.stringify(name)} };`
+		)
+	);
+	write(options.entrypoint, lines.join('\n'));
+}

package/src/build/jobs.ts

@@ -0,0 +1,63 @@
+import type { Analysis } from './types.ts';
+import type { Identity } from '../types/identity.ts';
+import type { Prerendered, PrerenderOption } from '../types/builder.ts';
+import type {
+	PrerenderHttpError,
+	PrerenderMissingId,
+	PrerenderEntryMismatch,
+	PrerenderUnseenRoutes,
+	PrerenderInvalidUrl
+} from '../types/config.ts';
+
+export interface WorkerPlatform {
+	identity: Identity;
+	directory: string;
+	assets: string;
+	origin: string;
+	environment: Record<string, string | undefined>;
+}
+export interface FallbackJob extends WorkerPlatform {
+	kind: 'fallback';
+}
+export interface AnalysisSources {
+	params: string | null;
+	extension: string;
+	endpoints: Record<string, string>;
+}
+export interface AnalysisJob extends WorkerPlatform {
+	kind: 'analyse';
+	hash: boolean;
+	sources: AnalysisSources;
+}
+export interface PrerenderJob extends WorkerPlatform {
+	kind: 'prerender';
+	root: string;
+	mode: string;
+	configFile?: string;
+	analysis: Analysis;
+	base: string;
+	hash: boolean;
+	entries: Array<'*' | `/${string}`>;
+	crawl: boolean;
+	concurrency: number;
+}
+export interface PrerenderResult {
+	prerendered: Prerendered;
+	prerenderMap: Map<string, PrerenderOption>;
+}
+export type WorkerJob = FallbackJob | AnalysisJob | PrerenderJob;
+export type WorkerValue = string | Analysis | PrerenderResult;
+export type PolicyIssue =
+	| { kind: 'handleHttpError'; details: PrerenderHttpError }
+	| { kind: 'handleMissingId'; details: PrerenderMissingId }
+	| { kind: 'handleEntryGeneratorMismatch'; details: PrerenderEntryMismatch }
+	| { kind: 'handleUnseenRoutes'; details: PrerenderUnseenRoutes }
+	| { kind: 'handleInvalidUrl'; details: PrerenderInvalidUrl };
+export type WorkerMessage =
+	| { kind: 'result'; value: WorkerValue }
+	| { kind: 'error'; error: { message: string; stack?: string } }
+	| { kind: 'policy'; id: number; issue: PolicyIssue };
+export interface PolicyReply {
+	id: number;
+}
+export type PolicyReporter = (issue: PolicyIssue) => Promise<void>;

package/src/build/manifest.ts

@@ -0,0 +1,130 @@
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { uneval } from 'devalue';
+import { lookup } from '../shared/mime.ts';
+import type { Route } from '../types/internal/routes.ts';
+import { posix, write } from './files.ts';
+import type { BuildContext, ManifestInput } from './types.ts';
+
+export function serverAssets(context: BuildContext, routes: Route[]): string[] {
+	const roots = ['index.js'];
+	for (const route of routes) {
+		if (route.endpoint) roots.push(context.artifacts.endpoints[route.id]!);
+		if (route.page)
+			for (const index of [...route.page.layouts, ...route.page.errors, route.page.leaf]) {
+				if (index === undefined) continue;
+				const node = context.artifacts.nodes[index]!;
+				roots.push(
+					node.component,
+					...[node.server, node.universal].filter((file): file is string => !!file)
+				);
+			}
+	}
+	const visited = new Set<string>();
+	const assets = new Set<string>();
+	function visit(file: string): void {
+		if (visited.has(file)) return;
+		visited.add(file);
+		const chunk = context.artifacts.chunks[file];
+		if (!chunk) return;
+		for (const asset of chunk.assets) assets.add(asset);
+		for (const dependency of chunk.imports) visit(dependency);
+	}
+	roots.forEach(visit);
+	return [...assets].sort();
+}
+
+export function manifestSource({ context, routes, relativePath }: ManifestInput): string {
+	const selected = routes;
+	const used = new Set([0, 1]);
+	for (const route of selected)
+		if (route.page) {
+			for (const node of [...route.page.layouts, ...route.page.errors, route.page.leaf])
+				if (node !== undefined) used.add(node);
+		}
+	const indices = [...used].sort((a, b) => a - b);
+	const reindex = new Map(indices.map((index, next) => [index, next]));
+	const location = (file: string) => {
+		const relative = posix(path.posix.join(relativePath, file));
+		return relative.startsWith('./') || relative.startsWith('../') ? relative : './' + relative;
+	};
+	const load = (file: string) =>
+		`__memo(() => import('${location(file).replace(/[\\']/g, '\\$&')}'))`;
+	const page = (route: Route) =>
+		route.page
+			? {
+					layouts: route.page.layouts.map((index) =>
+						index === undefined ? undefined : reindex.get(index)
+					),
+					errors: route.page.errors.map((index) =>
+						index === undefined ? undefined : reindex.get(index)
+					),
+					leaf: reindex.get(route.page.leaf)
+				}
+			: null;
+	const client = uneval(context.artifacts.client, (value) =>
+		context.artifacts.inlineStyle && value === context.artifacts.inlineStyle.render
+			? context.artifacts.inlineStyle.source
+			: undefined
+	);
+	const assets = [
+		...context.tree.assets.map((asset) => asset.file),
+		...[context.artifacts.serviceWorker].filter((file): file is string => !!file)
+	];
+	const mime = Object.fromEntries(
+		context.tree.assets
+			.filter((asset) => asset.type)
+			.map((asset) => [path.extname(asset.file), asset.type])
+	);
+	const files: Record<string, number> = {};
+	for (const file of serverAssets(context, routes)) {
+		files[file] = statSync(path.join(context.config.outDir, 'output/server', file)).size;
+		mime[path.extname(file)] ??= lookup(file) ?? '';
+	}
+	for (const pathname of context.prerendered.paths)
+		if (path.extname(pathname)) mime[path.extname(pathname)] ??= lookup(pathname) ?? '';
+	return `(() => { const __memo = (load) => { let value; return () => value ??= load(); }; return {
+app_dir: ${uneval(context.config.appDir)}, app_path: ${uneval([context.config.paths.base.slice(1), context.config.appDir].filter(Boolean).join('/'))},
+assets: new Set(${uneval(assets)}), mime_types: ${uneval(mime)}, client: ${client},
+nodes: [${indices.map((index) => load(`nodes/${index}.js`)).join(',')}],
+remotes: {${Object.entries(context.artifacts.remotes)
+		.map(([id, file]) => `'${id.replace(/[\\']/g, '\\$&')}': ${load(file)}`)
+		.join(',')}},
+routes: [${selected
+		.filter((route) => route.page || route.endpoint)
+		.map(
+			(route) =>
+				`{ id: ${uneval(route.id)}, pattern: ${route.pattern}, params: ${uneval(route.params)}, page: ${uneval(page(route))}, endpoint: ${route.endpoint ? load(context.artifacts.endpoints[route.id]!) : 'null'} }`
+		)
+		.join(',')}],
+prerendered_routes: new Set(${uneval(context.prerendered.paths)}), server_assets: ${uneval(files)},
+matchers: async () => ${context.artifacts.matchers && selected.some((route) => route.params.some((param) => param.matcher)) ? `(await import(${JSON.stringify(location(context.artifacts.matchers))})).params` : '{}'}
+}; })()`;
+}
+
+function universalCode(context: BuildContext, index: number, file: string): string {
+	const options = context.tree.nodes[index]?.options ?? null;
+	const inline =
+		(context.config.router.type === 'hash' && options !== null && options.ssr === undefined) ||
+		options?.ssr === false;
+	return inline
+		? `export const universal = ${uneval(options)};`
+		: `export * as universal from ${JSON.stringify('../' + posix(file))};`;
+}
+
+export function writeNodes(context: BuildContext): void {
+	for (const [index, node] of context.artifacts.nodes.entries()) {
+		const file = path.join(context.config.outDir, 'output/server/nodes', `${index}.js`);
+		const source = (name: string) => JSON.stringify('../' + posix(name));
+		write(
+			file,
+			`export const index = ${index};\nexport const imports = ${uneval(node.imports)}, stylesheets = ${uneval(node.stylesheets)}, fonts = ${uneval(node.fonts)};\nexport const universal_id = ${uneval(context.tree.nodes[index]?.universal)}, server_id = ${uneval(context.tree.nodes[index]?.server)};\n${
+				node.inlineStyles
+					? `export const inline_styles = () => ({${Object.entries(node.inlineStyles)
+							.map(([file, expression]) => `${JSON.stringify(file)}: (${expression})`)
+							.join(',')}});`
+					: ''
+			}\nexport const component = () => import(${source(node.component)}).then(module => module.default);\n${node.universal ? universalCode(context, index, node.universal) : ''}\n${node.server ? `export * as server from ${source(node.server)};` : ''}\n`
+		);
+	}
+}

package/src/build/messages.ts

@@ -0,0 +1,182 @@
+import type { Diagnostics } from '../shared/diagnostics.ts';
+
+interface InstrumentationMessage {
+	kind: string;
+	file: string;
+}
+interface FileMessage {
+	file: string;
+}
+interface RouteMessage {
+	id: string;
+}
+interface NameMessage {
+	name: string;
+}
+interface HashMessage {
+	file: string;
+	options: string;
+}
+interface PrerenderConflict {
+	path: string;
+	parent?: string;
+}
+function bulletList(items: string[]): string {
+	return items.map((item) => `  - ${item}`).join('\n');
+}
+
+export class BuildMessages {
+	private readonly d: Diagnostics;
+	constructor(d: Diagnostics) {
+		this.d = d;
+	}
+	adapter_instrumentation_file_missing({ kind, file }: InstrumentationMessage): never {
+		this.d.raise(
+			'adapter_instrumentation_file_missing',
+			`${kind} \`${file}\` not found. This is probably a bug in your adapter.`,
+			this.adapter_instrumentation_file_missing
+		);
+	}
+	adapter_read_unsupported({ route, adapter }: { route: string; adapter: string }): never {
+		this.d.raise(
+			'adapter_read_unsupported',
+			`Cannot use \`read\` from \`$app/server\` in \`${route}\` when using \`${adapter}\`. Please ensure that your adapter is up to date and supports this feature.`,
+			this.adapter_read_unsupported
+		);
+	}
+	adapter_fallback_overwrites({ file }: FileMessage): void {
+		this.d.warn(
+			'adapter_fallback_overwrites',
+			`Overwriting \`${file}\` with fallback page. Consider using a different name for the fallback.`
+		);
+	}
+	router_hash_page_options({ file, options }: HashMessage): never {
+		this.d.raise(
+			'router_hash_page_options',
+			`Page options are ignored when \`router.type === 'hash'\` (\`${file}\` has ${options})`,
+			this.router_hash_page_options
+		);
+	}
+	params_export_missing({ file }: FileMessage): never {
+		this.d.raise(
+			'params_export_missing',
+			`\`${file}\` does not export \`params\` from \`defineParams\``,
+			this.params_export_missing
+		);
+	}
+	param_matcher_missing({ name, file }: NameMessage & { file?: string }): never {
+		this.d.raise(
+			'param_matcher_missing',
+			`No matcher found for parameter \`${name}\`${file === undefined ? '' : ` in \`${file}\``}`,
+			this.param_matcher_missing
+		);
+	}
+	prerender_endpoint_methods({ id, methods }: RouteMessage & { methods: string }): never {
+		this.d.raise(
+			'prerender_endpoint_methods',
+			`Cannot prerender a \`+server\` file with ${methods} or fallback handlers (\`${id}\`)`,
+			this.prerender_endpoint_methods
+		);
+	}
+	route_prerender_page_and_endpoint({
+		id,
+		file,
+		extension
+	}: RouteMessage & FileMessage & { extension: string }): never {
+		this.d.raise(
+			'route_prerender_page_and_endpoint',
+			`Cannot prerender a route (\`${id}\`) with both a \`+page${extension}\` and a \`${file}\``,
+			this.route_prerender_page_and_endpoint
+		);
+	}
+	route_config_mismatch({ id }: RouteMessage): never {
+		this.d.raise(
+			'route_config_mismatch',
+			`Mismatched route config for \`${id}\` — the \`+page\` and \`+server\` files must export the same config, if any`,
+			this.route_config_mismatch
+		);
+	}
+	prerender_http_error(
+		status: number,
+		path: string,
+		referrer: string | null,
+		referenceType: string,
+		base: string
+	): string {
+		if (status === 404 && !path.startsWith(base))
+			return this.d.text(
+				'prerender_path_outside_base',
+				referrer
+					? `\`${path}\` (${referenceType} from \`${referrer}\`) does not begin with \`base\`. You can fix this by using \`resolve('${path}')\` from \`$app/paths\`. The base path is configurable from \`paths.base\``
+					: `\`${path}\` does not begin with \`base\`. You can fix this by using \`resolve('${path}')\` from \`$app/paths\`. The base path is configurable from \`paths.base\``
+			);
+		return this.d.text(
+			'prerender_http_error',
+			status === 404 && referrer
+				? `\`${path}\` was ${referenceType} from \`${referrer}\``
+				: `Failed to prerender \`${path}\``
+		);
+	}
+	prerender_invalid_url(href: string, referrer: string | null): string {
+		return this.d.text(
+			'prerender_invalid_url',
+			referrer ? `Invalid URL \`${href}\` (linked from \`${referrer}\`)` : `Invalid URL \`${href}\``
+		);
+	}
+	prerender_directory_conflict({ path, parent }: PrerenderConflict): never {
+		this.d.raise(
+			'prerender_directory_conflict',
+			`Cannot save \`${path}\` as ${parent === undefined ? 'it is already a directory' : `\`${parent}\` is already a file`}.${this.d.docs('prerenderConflicts', (url) => ` See ${url} for more information`)}`,
+			this.prerender_directory_conflict
+		);
+	}
+	prerender_missing_id(path: string, id: string, referrers: string[]): string {
+		return this.d.text(
+			'prerender_missing_id',
+			`The following pages contain links to \`${path}#${id}\`, but no element with \`id="${id}"\` exists on \`${path}\`:\n${bulletList(referrers)}`
+		);
+	}
+	prerender_entry_generator_mismatch(id: string, entry: string, matched: string): string {
+		return this.d.text(
+			'prerender_entry_generator_mismatch',
+			`The \`entries\` export from \`${id}\` generated entry \`${entry}\`, which was matched by \`${matched === entry ? 'a static route' : matched}\``
+		);
+	}
+	prerender_unseen_routes(routes: string[]): string {
+		return this.d.text(
+			'prerender_unseen_routes',
+			`The following routes were marked as prerenderable, but were not prerendered because they were not found while crawling your app:\n${bulletList(routes)}`
+		);
+	}
+	prerender_policy_hint(name: string): string {
+		const link = this.d.identity.links?.prerender;
+		return `To suppress or handle this error, implement \`${name}\` in ${link ?? `the \`prerender\` options of \`${this.d.identity.plugin}(...)\``}`;
+	}
+	prerender_root_non_html({ base }: { base: string }): never {
+		this.d.raise(
+			'prerender_root_non_html',
+			`Cannot prerender a root \`+server.js\` that returns a non-HTML response — static hosts always serve an HTML file for \`${base}\``,
+			this.prerender_root_non_html
+		);
+	}
+	prerender_redirect_location_missing({ path }: { path: string }): void {
+		this.d.warn(
+			'prerender_redirect_location_missing',
+			`\`location\` header missing on redirect received from \`${path}\``
+		);
+	}
+	prerender_client_address(): never {
+		this.d.raise(
+			'prerender_client_address',
+			'Cannot read `clientAddress` during prerendering',
+			this.prerender_client_address
+		);
+	}
+	prerender_fallback_failed(): never {
+		this.d.raise(
+			'prerender_fallback_failed',
+			'Could not create a fallback page',
+			this.prerender_fallback_failed
+		);
+	}
+}