@vigla/kit 0.0.0-stage → 0.1.1

package/src/vite/modules.ts

@@ -0,0 +1,213 @@
+import path from 'node:path';
+import type { Plugin, ResolvedConfig, Rolldown } from 'vite';
+import type { ValidatedConfig } from '../types/builder.ts';
+import { installation, resolveEntry } from '../sync/index.ts';
+import { compileComponent, componentNames } from '../components/index.ts';
+import { clientApp, clientNode } from './client.ts';
+import { environmentConfig, environmentModule, workerEnvironment } from './env.ts';
+import { clientDirectory, ids, virtualDirectory } from './ids.ts';
+import type { ViteMessages } from './messages.ts';
+import {
+	appModules,
+	fileUrl,
+	importAliases,
+	isServerOnly,
+	normalizeId,
+	packageImporter,
+	moduleUrl,
+	posix
+} from './paths.ts';
+import type { Project } from './project.ts';
+import { errorTemplate, serverEntry, serverManifest, serverOptions } from './server.ts';
+
+export function scanVirtualModules(): Rolldown.Plugin {
+	return {
+		name: 'kit:scan-virtual-modules',
+		resolveId: {
+			filter: {
+				id: [
+					/^\$app\//,
+					/\/generated\/(?:dev|build)\/client\/nodes\//,
+					new RegExp(virtualDirectory.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+				]
+			},
+			async handler(id, importer) {
+				const resolved = await this.resolve(id, importer, { skipSelf: true });
+				const target = resolved?.id ?? id;
+				return { id: path.isAbsolute(target) ? fileUrl(target) : target, external: 'absolute' };
+			}
+		}
+	};
+}
+
+export function virtualModules(
+	getConfig: () => ValidatedConfig,
+	getProject: () => Project
+): Plugin {
+	let vite: ResolvedConfig;
+	let name: string;
+	return {
+		name: 'kit:modules',
+		enforce: 'pre',
+		configResolved(resolved) {
+			vite = resolved;
+			name = installation(vite.root).name;
+		},
+		async resolveId(id, importer, options) {
+			const config = getConfig();
+			if (id.startsWith('/@fs/')) id = id.slice(4);
+			if (id.startsWith(virtualDirectory)) return path.posix.normalize(id);
+			const nodes = clientDirectory(config, vite) + '/nodes/';
+			if (id.startsWith(nodes)) return path.posix.normalize(id);
+			const url = moduleUrl(clientDirectory(config, vite), vite.root) + '/nodes/';
+			if (id.startsWith(url)) return nodes + id.slice(url.length);
+			if (id === '$app/manifest') return ids.appManifest;
+			if (id === '$app/env/public') return ids.publicEnv;
+			if (id === '$app/env/private') return ids.privateEnv;
+			if (id.startsWith('$app/') && appModules.has(id.slice(5)))
+				return await this.resolve(`#${id.slice(1)}`, packageImporter, {
+					...options,
+					skipSelf: true
+				});
+			if (importer?.startsWith(virtualDirectory) && id.startsWith(name + '/')) {
+				return await this.resolve(id, path.join(vite.root, 'package.json'), {
+					...options,
+					skipSelf: true
+				});
+			}
+			if (importer?.startsWith(virtualDirectory) && (id === 'vigla' || id.startsWith('vigla/'))) {
+				return await this.resolve(id, packageImporter, { ...options, skipSelf: true });
+			}
+		},
+		load(id) {
+			const nodes = clientDirectory(getConfig(), vite) + '/nodes/';
+			if (!id.startsWith(virtualDirectory) && !id.startsWith(nodes)) return;
+			const project = getProject();
+			const { config, tree, root, name, format, environment } = project;
+			const client = this.environment.config.consumer === 'client';
+			const placeholders =
+				project.vite.command === 'build' && this.environment.name !== 'serviceWorker';
+			if (id === ids.appManifest)
+				return `export const immutable = ${placeholders ? '__VIGLA_MANIFEST_IMMUTABLE__' : JSON.stringify(project.build?.manifest.immutable ?? [])}, prerendered = ${placeholders ? '__VIGLA_MANIFEST_PRERENDERED__' : JSON.stringify(project.build?.manifest.prerendered ?? [])}; export const assets = ${JSON.stringify(tree.assets.map((asset) => ({ path: asset.file })))}; export const routes = ${JSON.stringify(tree.routes.filter((route) => route.page || route.endpoint).map((route) => ({ id: route.id, page: !!route.page, endpoint: !!route.endpoint })))};`;
+			if (id === ids.bootstrap)
+				return `import { init } from ${JSON.stringify(name + '/internal/payload')}; init(globalThis[${JSON.stringify(project.global)}]);`;
+			if (id === ids.client) return clientApp(project);
+			if (id === ids.bundle)
+				return `import ${JSON.stringify(ids.bootstrap)}; import { init, start as boot } from ${JSON.stringify(name + '/internal/client')}; import * as app from ${JSON.stringify(ids.client)}; export { init }; export const decode = app.decode; export function start(target,hydrate) { return boot(app,target,hydrate); }`;
+			if (id === ids.server) return serverEntry(name, project.vite.command === 'serve');
+			if (id === ids.manifest) return serverManifest(project);
+			if (id === ids.options) return serverOptions(project);
+			if (id === ids.errorTemplate) return errorTemplate(project);
+			if (id === ids.env)
+				return environmentConfig(environment, name, project.vite.command === 'serve');
+			if (id === ids.workerEnv)
+				return workerEnvironment(environment, config, name, project.vite.command === 'serve');
+			if (id === ids.workerIdentity)
+				return `globalThis.__VIGLA_IDENTITY__ = ${JSON.stringify(project.identity)};`;
+			if (id === ids.publicEnv)
+				return environmentModule(environment, 'public', client, project.vite.command === 'serve');
+			if (id === ids.privateEnv)
+				return environmentModule(environment, 'private', false, project.vite.command === 'serve');
+			const node = /^(\d+)\.js$/.exec(id.slice(nodes.length));
+			if (id.startsWith(nodes) && node) {
+				const index = Number(node[1]);
+				const value = tree.nodes[index];
+				if (!value) throw new Error(`Unknown client node ${index}`);
+				return clientNode(value, index, root);
+			}
+			for (const name of componentNames) {
+				if (id !== ids[name]) continue;
+				const compiled = compileComponent(name, {
+					generate: client ? 'client' : 'server',
+					dev: project.vite.command === 'serve',
+					announcer: project.identity.announcer,
+					format
+				});
+				return { code: compiled.code, map: JSON.stringify(compiled.map) };
+			}
+		},
+		transform(code, id) {
+			if (this.environment.config.consumer !== 'client') return;
+			const config = getConfig();
+			const file = id.split('?')[0]!;
+			if (!file.startsWith(config.files.serviceWorker)) return;
+			if (file !== resolveEntry(config.files.serviceWorker, config.moduleExtensions)) return;
+			const imports =
+				getProject().vite.command === 'serve'
+					? [ids.workerIdentity, ids.workerEnv]
+					: [ids.workerEnv];
+			return {
+				code: `${imports.map((id) => `import ${JSON.stringify(id)};\n`).join('')}${code}`,
+				map: null
+			};
+		}
+	};
+}
+
+export function serverGuard(getConfig: () => ValidatedConfig, e: ViteMessages): Plugin {
+	let root: string;
+	const importers = new Map<string, Set<string>>();
+	const special = new Map<string, string>();
+	function chain(id: string, seen = new Set<string>()): string[] {
+		if (seen.has(id)) return [];
+		seen.add(id);
+		for (const parent of importers.get(id) ?? []) {
+			if (seen.has(parent)) continue;
+			return [...chain(parent, seen), parent];
+		}
+		return [];
+	}
+	return {
+		name: 'kit:server-only',
+		enforce: 'pre',
+		configResolved(vite) {
+			root = vite.root;
+		},
+		applyToEnvironment(environment) {
+			return environment.config.consumer === 'client';
+		},
+		async resolveId(id, importer, options) {
+			if (!importer || importer.endsWith('/index.html') || importer === packageImporter) return;
+			const resolved = await this.resolve(id, importer, { ...options, skipSelf: true });
+			if (!resolved) return;
+			const file = posix(resolved.id.split('?')[0]!);
+			const parents = importers.get(file) ?? new Set<string>();
+			parents.add(posix(importer.split('?')[0]!));
+			importers.set(file, parents);
+			if (id === '$app/server' || /^\$.+\/private$/.test(id)) special.set(file, id);
+		},
+		load(id) {
+			const config = getConfig();
+			id = posix(id.split('?')[0]!);
+			const alias = importAliases(root);
+			const pretty = (file: string) => special.get(file) ?? normalizeId(file, alias, root);
+			if (
+				special.has(id) ||
+				id === ids.privateEnv ||
+				id === ids.env ||
+				isServerOnly(id, {
+					root: posix(root),
+					node_modules: posix(path.join(root, 'node_modules')),
+					routes: posix(config.files.routes),
+					assets: posix(config.files.assets)
+				})
+			) {
+				const generated = posix(path.join(config.outDir, 'generated')) + '/';
+				const names = [...chain(id), id]
+					.filter(
+						(file) =>
+							(!file.startsWith(virtualDirectory) && !file.startsWith(generated)) || file === id
+					)
+					.map(pretty);
+				e.server_only_import({
+					module: id === ids.privateEnv ? '$app/env/private' : pretty(id),
+					chain: names.map((name, index) => `${' '.repeat(index + 1)}${name}`).join(' imports\n')
+				});
+			}
+		},
+		buildEnd() {
+			importers.clear();
+			special.clear();
+		}
+	};
+}

package/src/vite/paths.ts

@@ -0,0 +1,131 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { Plugin } from 'vite';
+
+export const packageDirectory = fileURLToPath(new URL('../../', import.meta.url));
+export const codeDirectory = fileURLToPath(new URL('../', import.meta.url));
+const codeExtension = path.extname(fileURLToPath(import.meta.url));
+export function codeFile(name: string): string {
+	return path.join(codeDirectory, name + codeExtension);
+}
+export const packageImporter = codeFile('vite/index');
+const sourceDirectory = posix(codeDirectory);
+
+export interface ImportAlias {
+	alias: string;
+	path: string;
+}
+export interface ProjectDirectories {
+	root: string;
+	node_modules: string;
+	routes: string;
+	assets: string;
+}
+interface PackageManifest {
+	name?: string;
+	imports?: Record<string, unknown>;
+	peerDependencies?: Record<string, string>;
+}
+
+const manifest = JSON.parse(
+	readFileSync(path.join(packageDirectory, 'package.json'), 'utf8')
+) as PackageManifest;
+export const appModules = new Set(
+	Object.keys(manifest.imports ?? {})
+		.filter((key) => key.startsWith('#app/'))
+		.map((key) => key.slice(5))
+);
+
+export function posix(file: string): string {
+	return file.replaceAll('\\', '/');
+}
+
+export function fileUrl(file: string): string {
+	const normalized = posix(file);
+	return `/@fs${normalized.startsWith('/') ? '' : '/'}${normalized}`;
+}
+
+export function moduleUrl(file: string, root: string): string {
+	const relative = posix(path.relative(root, file));
+	return relative === '..' || relative.startsWith('../') || path.isAbsolute(relative)
+		? fileUrl(file)
+		: '/' + relative;
+}
+
+function targets(value: unknown): string[] {
+	if (typeof value === 'string') return [value];
+	if (value === null || typeof value !== 'object') return [];
+	return Object.values(value).flatMap(targets);
+}
+
+export function importAliases(root: string): ImportAlias[] {
+	const file = path.join(root, 'package.json');
+	if (!existsSync(file)) return [];
+	const manifest = JSON.parse(readFileSync(file, 'utf8')) as PackageManifest;
+	return Object.entries(manifest.imports ?? {})
+		.flatMap(([alias, value]) =>
+			targets(value)
+				.filter((target) => target.startsWith('./'))
+				.map((target) => ({
+					alias: alias.replace(/\/\*$/, ''),
+					path: posix(path.resolve(root, target.replace(/\/\*$/, '')))
+				}))
+		)
+		.sort((a, b) => b.path.length - a.path.length);
+}
+
+export function normalizeId(id: string, aliases: ImportAlias[], root: string): string {
+	id = posix(id.replace(/\?.*$/s, ''));
+	if (id === posix(codeFile('entries/app/server/server'))) return '$app/server';
+	if (id === posix(codeFile('entries/app/env/private/server'))) return '$app/env/private';
+	for (const alias of aliases) {
+		if (id === alias.path || id.startsWith(alias.path + '/')) {
+			return alias.alias + id.slice(alias.path.length);
+		}
+	}
+	return id.startsWith(root + '/') ? id.slice(root.length + 1) : id;
+}
+
+export const remotePattern = /[/.]remote\.[^/]+$/;
+export const serverPattern = /[/.]server\.[^/]+$/;
+export const serverDirectory = /\/server\//;
+
+export function isServerOnly(id: string, dirs: ProjectDirectories): boolean {
+	id = posix(id.split('?')[0]!);
+	if (!id.startsWith(dirs.root + '/') || id.startsWith(dirs.node_modules + '/')) return false;
+	const relative = id.slice(dirs.root.length);
+	return (
+		serverPattern.test(relative) ||
+		(serverDirectory.test(relative) &&
+			!id.startsWith(dirs.routes + '/') &&
+			!id.startsWith(dirs.assets + '/'))
+	);
+}
+
+export function isRemoteModule(id: string, packages: readonly string[]): boolean {
+	id = posix(id);
+	if (!remotePattern.test(id)) return false;
+	if (id.startsWith(sourceDirectory)) return false;
+	if (!id.split('/').includes('node_modules')) return true;
+	let directory = path.dirname(id);
+	while (path.basename(directory) !== 'node_modules') {
+		const file = path.join(directory, 'package.json');
+		if (existsSync(file)) {
+			const manifest = JSON.parse(readFileSync(file, 'utf8')) as PackageManifest;
+			if (packages.some((name) => manifest.peerDependencies?.[name])) return true;
+		}
+		const parent = path.dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	return false;
+}
+
+export function usesHtmlHook(plugin: Plugin): boolean {
+	return (
+		!!plugin.transformIndexHtml &&
+		plugin.name !== 'vitest:browser:loader' &&
+		!plugin.name?.includes('storybook')
+	);
+}

package/src/vite/preview.ts

@@ -0,0 +1,215 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { PreviewServer } from 'vite';
+import { createReadableStream, getRequest, setResponse } from '../node/index.ts';
+import { serveFile, type FileRepresentation } from '../node/static.ts';
+import { walk } from '../build/index.ts';
+import type { PrerenderedAsset, PrerenderedPage, PrerenderedRedirect } from '../types/builder.ts';
+import type { ServerManifest, ServerModule } from '../types/internal/server.ts';
+import { outsideBase } from './assets.ts';
+import { ViteMessages } from './messages.ts';
+import type { Project } from './project.ts';
+
+const scope = new AsyncLocalStorage();
+
+interface StoredPrerender {
+	pages: Array<[string, PrerenderedPage]>;
+	assets: Array<[string, PrerenderedAsset]>;
+	redirects: Array<[string, PrerenderedRedirect]>;
+	paths: string[];
+}
+
+export async function configurePreview(
+	preview: PreviewServer,
+	project: Project
+): Promise<() => void> {
+	const output = path.join(project.config.outDir, 'output');
+	const directory = path.join(output, 'server');
+	if (!existsSync(path.join(directory, 'manifest.js')))
+		new ViteMessages(project.diagnostics).preview_build_missing({ dir: directory });
+	const module = (await import(
+		pathToFileURL(path.join(directory, 'index.js')).href
+	)) as ServerModule;
+	const { manifest } = (await import(pathToFileURL(path.join(directory, 'manifest.js')).href)) as {
+		manifest: ServerManifest;
+	};
+	const remotePrefix = `/${manifest.app_path}/remote/`;
+	const assetsPrefix = project.config.paths.assets
+		? project.identity.assets
+		: project.config.paths.base;
+	const read = (root: string, file: string) => {
+		const absolute = path.resolve(root, file);
+		return absolute.startsWith(root + path.sep) && existsSync(absolute)
+			? createReadableStream(absolute)
+			: null;
+	};
+	const instrumentation = path.join(directory, 'instrumentation.server.js');
+	if (existsSync(instrumentation)) await import(pathToFileURL(instrumentation).href);
+	const server = await module.configure({
+		manifest,
+		env: project.environment.values,
+		read: (file) => read(directory, file),
+		assets: assetsPrefix,
+		scope
+	});
+	await server.init();
+	const stored = JSON.parse(
+		readFileSync(path.join(output, 'prerendered.json'), 'utf8')
+	) as StoredPrerender;
+	const pages = new Map(stored.pages),
+		dependencies = new Map(stored.assets),
+		redirects = new Map(stored.redirects);
+	const client = path.join(output, 'client');
+	const clientFiles = new Set(walk(client).filter((file) => !file.startsWith('.vite/')));
+	const representations = new Map<string, FileRepresentation>();
+	const emulator = await project.config.adapter?.emulate?.();
+	function representation(
+		root: string,
+		file: string,
+		type?: string,
+		immutable = false
+	): FileRepresentation {
+		const key = path.join(root, file);
+		let value = representations.get(key);
+		if (!value) {
+			value = {
+				file,
+				type,
+				etag: `"${createHash('sha256').update(readFileSync(key)).digest('base64url')}"`,
+				cacheControl: immutable ? 'public,max-age=31536000,immutable' : 'no-cache'
+			};
+			representations.set(key, value);
+		}
+		return value;
+	}
+	return () => {
+		for (let index = preview.middlewares.stack.length - 1; index >= 0; index--) {
+			const layer = preview.middlewares.stack[index]!;
+			if (
+				'name' in layer.handle &&
+				['viteBaseMiddleware', 'viteAssetMiddleware', 'vitePreviewMiddleware'].includes(
+					layer.handle.name
+				)
+			)
+				preview.middlewares.stack.splice(index, 1);
+		}
+		preview.middlewares.use(async (request, response, next) => {
+			try {
+				const origin = `${preview.config.preview.https ? 'https' : 'http'}://${request.headers[':authority'] ?? request.headers.host}`;
+				const url = new URL(request.originalUrl ?? request.url ?? '/', origin);
+				let pathname: string;
+				try {
+					pathname = decodeURI(url.pathname);
+				} catch {
+					response.writeHead(400);
+					response.end('Malformed URI');
+					return;
+				}
+				if (pathname.startsWith(assetsPrefix + '/')) {
+					const file = decodeURIComponent(url.pathname.slice(assetsPrefix.length + 1));
+					if (
+						clientFiles.has(file) &&
+						serveFile({
+							directory: client,
+							pathname: '/' + file,
+							request,
+							response,
+							representation: representation(
+								client,
+								file,
+								undefined,
+								file.startsWith(project.config.appDir + '/immutable/')
+							)
+						})
+					)
+						return;
+				}
+				if (pathname === '/.well-known/appspecific/com.chrome.devtools.json') {
+					response.writeHead(404);
+					response.end('not found');
+					return;
+				}
+				const base = project.config.paths.base;
+				if (base && pathname === base) {
+					response.writeHead(307, { location: base + '/' + url.search });
+					response.end();
+					return;
+				}
+				if (base && !pathname.startsWith(base + '/')) {
+					outsideBase(request, response, base);
+					return;
+				}
+				const page = pages.get(pathname);
+				if (page) {
+					const root = path.join(output, 'prerendered/pages');
+					if (
+						serveFile({
+							directory: root,
+							pathname,
+							request,
+							response,
+							representation: representation(root, page.file, 'text/html')
+						})
+					)
+						return;
+				}
+				const normalized = pathname.endsWith('/') ? pathname.slice(0, -1) : pathname + '/';
+				if (pages.has(normalized)) {
+					const location = url.pathname.endsWith('/')
+						? url.pathname.slice(0, -1)
+						: url.pathname + '/';
+					response.writeHead(308, { location: location + url.search });
+					response.end();
+					return;
+				}
+				const redirect = redirects.get(pathname);
+				if (redirect) {
+					response.writeHead(redirect.status, { location: redirect.location });
+					response.end();
+					return;
+				}
+				const dependency = dependencies.get(pathname);
+				if (dependency) {
+					const root = path.join(
+						output,
+						'prerendered',
+						pathname.endsWith('/__data.json') || pathname.startsWith(remotePrefix)
+							? 'data'
+							: 'dependencies'
+					);
+					const file = pathname.slice(base.length + 1) || 'index.html';
+					if (
+						serveFile({
+							directory: root,
+							pathname,
+							request,
+							response,
+							representation: representation(root, file, dependency.type)
+						})
+					)
+						return;
+				}
+				const web = (project.config.adapter?.vite?.getRequest ?? getRequest)({
+					request,
+					response,
+					base: origin
+				});
+				const result = await server.respond(web, {
+					read: (file) =>
+						read(Object.hasOwn(manifest.server_assets, file) ? directory : client, file),
+					getClientAddress: () => {
+						if (!request.socket.remoteAddress) throw new Error('Could not determine clientAddress');
+						return request.socket.remoteAddress;
+					},
+					emulator
+				});
+				(project.config.adapter?.vite?.setResponse ?? setResponse)(response, result);
+			} catch (error) {
+				next(error);
+			}
+		});
+	};
+}

package/src/vite/project.ts

@@ -0,0 +1,27 @@
+import type { ResolvedConfig } from 'vite';
+import type { Format } from 'vigla/compiler';
+import type { Sync, Environment } from '../sync/index.ts';
+import type { Diagnostics } from '../shared/diagnostics.ts';
+import type { ValidatedConfig } from '../types/builder.ts';
+import type { Identity } from '../types/identity.ts';
+import type { RouteTree } from '../types/internal/routes.ts';
+import type { BuildContext } from '../build/index.ts';
+import type { RemoteIntegration } from './remote.ts';
+
+export interface Project {
+	identity: Identity;
+	diagnostics: Diagnostics;
+	root: string;
+	name: string;
+	global: string;
+	remote: RemoteIntegration;
+	build?: BuildContext;
+	config: ValidatedConfig;
+	vite: ResolvedConfig;
+	api: typeof import('vite');
+	sync: Sync;
+	tree: RouteTree;
+	environment: Environment;
+	format?: Format;
+	serviceWorker: string | null;
+}