@useavalon/avalon 0.1.0

package/src/build/integration-resolver-plugin.ts

@@ -0,0 +1,90 @@
+import type { Plugin } from 'vite';
+import { resolve } from 'node:path';
+
+/**
+ * Vite plugin to resolve integration package imports
+ * Handles both @useavalon/integration-* imports and relative imports within integrations
+ */
+export function integrationResolverPlugin(): Plugin {
+	const cwd = process.cwd();
+	
+	return {
+		name: 'avalon:integration-resolver',
+		enforce: 'pre',
+
+		resolveId(id: string, importer?: string) {
+			// Handle @useavalon/integration-* imports
+			if (id.startsWith('@useavalon/integration-')) {
+				const parts = id.split('/');
+				const framework = parts[1].replace('integration-', '');
+				const subpath = parts.slice(2).join('/');
+				
+				// Map to actual file paths
+				if (!subpath || subpath === '') {
+					// Main export: @useavalon/integration-preact -> packages/integrations/preact/mod.ts
+					return resolve(cwd, `packages/integrations/${framework}/mod.ts`);
+				} else if (subpath === 'server') {
+					// Server export: @useavalon/integration-preact/server -> packages/integrations/preact/server/renderer.ts
+					return resolve(cwd, `packages/integrations/${framework}/server/renderer.ts`);
+				} else if (subpath === 'client') {
+					// Client export: @useavalon/integration-preact/client -> packages/integrations/preact/client/index.ts
+					return resolve(cwd, `packages/integrations/${framework}/client/index.ts`);
+				} else if (subpath === 'types') {
+					// Types export: @useavalon/integration-preact/types -> packages/integrations/preact/types.ts
+					return resolve(cwd, `packages/integrations/${framework}/types.ts`);
+				}
+			}
+			
+			// Handle @useavalon/shared imports (used by integrations)
+			if (id === '@useavalon/shared' || id === '@useavalon/shared/types') {
+				return resolve(cwd, 'packages/integrations/shared/types.ts');
+			}
+			
+			// Handle relative imports within integrations
+			if (importer && importer.includes('/integrations/')) {
+				if (id.startsWith('../shared/')) {
+					const sharedPath = id.replace('../shared/', '');
+					return resolve(cwd, `packages/integrations/shared/${sharedPath}`);
+				}
+			}
+			
+			return null;
+		},
+
+		load(id: string) {
+			// Handle virtual modules if needed
+			return null;
+		},
+	};
+}
+
+/**
+ * Create alias configuration for integration imports
+ */
+export function createIntegrationAliases(): Record<string, string> {
+	const cwd = process.cwd();
+	
+	return {
+		'@useavalon/integration-preact': resolve(cwd, 'packages/integrations/preact/mod.ts'),
+		'@useavalon/integration-preact/server': resolve(cwd, 'packages/integrations/preact/server/renderer.ts'),
+		'@useavalon/integration-preact/client': resolve(cwd, 'packages/integrations/preact/client/index.ts'),
+		'@useavalon/integration-vue': resolve(cwd, 'packages/integrations/vue/mod.ts'),
+		'@useavalon/integration-vue/server': resolve(cwd, 'packages/integrations/vue/server/renderer.ts'),
+		'@useavalon/integration-vue/client': resolve(cwd, 'packages/integrations/vue/client/index.ts'),
+		'@useavalon/integration-solid': resolve(cwd, 'packages/integrations/solid/mod.ts'),
+		'@useavalon/integration-solid/server': resolve(cwd, 'packages/integrations/solid/server/renderer.ts'),
+		'@useavalon/integration-solid/client': resolve(cwd, 'packages/integrations/solid/client/index.ts'),
+		'@useavalon/integration-svelte': resolve(cwd, 'packages/integrations/svelte/mod.ts'),
+		'@useavalon/integration-svelte/server': resolve(cwd, 'packages/integrations/svelte/server/renderer.ts'),
+		'@useavalon/integration-svelte/client': resolve(cwd, 'packages/integrations/svelte/client/index.ts'),
+		'@useavalon/integration-react': resolve(cwd, 'packages/integrations/react/mod.ts'),
+		'@useavalon/integration-react/server': resolve(cwd, 'packages/integrations/react/server/renderer.ts'),
+		'@useavalon/integration-react/client': resolve(cwd, 'packages/integrations/react/client/index.ts'),
+		'@useavalon/integration-react/types': resolve(cwd, 'packages/integrations/react/types.ts'),
+		'@useavalon/integration-lit': resolve(cwd, 'packages/integrations/lit/mod.ts'),
+		'@useavalon/integration-lit/server': resolve(cwd, 'packages/integrations/lit/server/renderer.ts'),
+		'@useavalon/integration-lit/client': resolve(cwd, 'packages/integrations/lit/client/index.ts'),
+		'@useavalon/integration-lit/types': resolve(cwd, 'packages/integrations/lit/types.ts'),
+		'@useavalon/shared': resolve(cwd, 'packages/integrations/shared/types.ts'),
+	};
+}

package/src/build/island-manifest.ts

@@ -0,0 +1,269 @@
+import { readFile } from 'node:fs/promises';
+import {
+	getQualifiedIslandName,
+	type IslandDirectory,
+	type IslandCollision,
+	createIslandRegistry,
+} from '../islands/discovery/index.ts';
+
+export interface IslandManifest {
+	islands: Record<string, IslandEntry>;
+	version: string;
+	buildTime: number;
+}
+
+/**
+ * Extended island manifest with nested islands support
+ */
+export interface ExtendedIslandManifest extends IslandManifest {
+	/** All discovered island directories */
+	directories: IslandDirectory[];
+	/** Detected naming collisions */
+	collisions: IslandCollision[];
+}
+
+export interface IslandEntry {
+	/** Original source path */
+	src: string;
+	/** Built bundle path */
+	bundle: string;
+	/** Bundle hash for cache busting */
+	hash: string;
+	/** Framework type (preact, solid, vue, svelte, vanilla, lit, react) */
+	framework: 'preact' | 'solid' | 'vue' | 'svelte' | 'vanilla' | 'lit' | 'react' | 'unknown';
+	/** Import dependencies */
+	deps: string[];
+}
+
+/**
+ * Extended island entry with namespace support
+ */
+export interface ExtendedIslandEntry extends IslandEntry {
+	/** Namespace for the island (empty string for default directory) */
+	namespace: string;
+	/** Qualified name including namespace (e.g., "modules/auth/Counter") */
+	qualifiedName: string;
+	/** Original directory path */
+	sourceDirectory: string;
+}
+
+/**
+ * Generate island manifest during build using the nested islands discovery service.
+ * Discovers all islands across all directories and generates manifest entries
+ * with namespace and qualified name support.
+ */
+export async function generateIslandManifest(): Promise<ExtendedIslandManifest> {
+	const islands: Record<string, ExtendedIslandEntry> = {};
+	const cwd = process.cwd();
+
+	try {
+		// Use the discovery service to find all islands
+		const registry = await createIslandRegistry(cwd);
+		const discoveredIslands = registry.getAllIslands();
+		const directories = registry.directories;
+		const collisions = registry.collisions;
+
+		for (const island of discoveredIslands) {
+			const qualifiedName = getQualifiedIslandName(island);
+			const src = `/${island.relativePath}`;
+
+			// Read file content for analysis
+			const content = await readFile(island.filePath, 'utf-8');
+			const framework = mapFrameworkType(island.framework);
+			const deps = extractDependencies(content);
+			const hash = await generateHash(content);
+
+			// Generate bundle path based on qualified name
+			const bundlePath =
+				island.namespace === ''
+					? `/dist/islands/${island.name}.${hash}.js`
+					: `/dist/islands/${qualifiedName}.${hash}.js`;
+
+			islands[qualifiedName] = {
+				src,
+				bundle: bundlePath,
+				hash,
+				framework,
+				deps,
+				namespace: island.namespace,
+				qualifiedName,
+				sourceDirectory: island.directory.relativePath,
+			};
+		}
+
+		return {
+			islands,
+			directories,
+			collisions,
+			version: '1.0.0',
+			buildTime: Date.now(),
+		};
+	} catch (error) {
+		console.warn('Failed to generate island manifest:', error);
+		return {
+			islands: {},
+			directories: [],
+			collisions: [],
+			version: '1.0.0',
+			buildTime: Date.now(),
+		};
+	}
+}
+
+/**
+ * Map the discovery service framework type to manifest framework type
+ */
+function mapFrameworkType(framework: string): ExtendedIslandEntry['framework'] {
+	switch (framework) {
+		case 'preact':
+			return 'preact';
+		case 'react':
+			return 'react';
+		case 'solid':
+			return 'solid';
+		case 'vue':
+			return 'vue';
+		case 'svelte':
+			return 'svelte';
+		case 'lit':
+			return 'lit';
+		case 'unknown':
+		default:
+			return 'vanilla';
+	}
+}
+
+
+/**
+ * Extract import dependencies from the island file
+ */
+function extractDependencies(content: string): string[] {
+	const deps: string[] = [];
+	const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+
+	let match;
+	while ((match = importRegex.exec(content)) !== null) {
+		const importPath = match[1];
+		// Only include external dependencies, not relative imports
+		if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
+			deps.push(importPath);
+		}
+	}
+
+	return [...new Set(deps)]; // Remove duplicates
+}
+
+/**
+ * Generate hash from content for cache busting
+ */
+async function generateHash(content: string): Promise<string> {
+	const encoder = new TextEncoder();
+	const data = encoder.encode(content);
+	const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+	const hashArray = Array.from(new Uint8Array(hashBuffer));
+	const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+	return hashHex.slice(0, 8); // Use first 8 characters
+}
+
+/**
+ * Load island manifest (for production)
+ */
+export async function loadIslandManifest(): Promise<ExtendedIslandManifest | null> {
+	try {
+		const manifestPath = 'dist/island-manifest.json';
+		const content = await readFile(manifestPath, 'utf-8');
+		return JSON.parse(content);
+	} catch (error) {
+		console.warn('Failed to load island manifest:', error);
+		return null;
+	}
+}
+
+/**
+ * Get bundle path for an island (development vs production)
+ * Supports both simple names and qualified names (namespace/name)
+ */
+export function getIslandBundlePath(src: string, manifest?: ExtendedIslandManifest | IslandManifest | null): string {
+	const isDev = process.env.NODE_ENV !== 'production';
+
+	// If manifest is provided, use it (production mode)
+	if (manifest) {
+		const qualifiedName = extractQualifiedNameFromSrc(src);
+		const extendedManifest = manifest as ExtendedIslandManifest;
+		if (extendedManifest.islands[qualifiedName]) {
+			return extendedManifest.islands[qualifiedName].bundle;
+		}
+		const simpleName = src.replace(/^\/islands\//, '').replace(/\.(tsx?|jsx?|vue|svelte)$/, '');
+		const island = manifest.islands[simpleName];
+		if (island) {
+			return island.bundle;
+		}
+	}
+
+	if (isDev) {
+		if (src.startsWith('/islands/')) {
+			return src.replaceAll('/islands/', '/src/islands/');
+		}
+		if (src.startsWith('/src/')) {
+			return src;
+		}
+		if (src.startsWith('/app/')) {
+			return src;
+		}
+		// For paths that don't start with /src/ or /app/, prefix with /src/
+		// but avoid double slashes
+		if (src.startsWith('/')) {
+			return src;
+		}
+		return `/src/${src}`;
+	}
+
+	const qualifiedName = extractQualifiedNameFromSrc(src);
+	return `/dist/islands/${qualifiedName}.js`;
+}
+
+/**
+ * Extract qualified name from a source path
+ */
+function extractQualifiedNameFromSrc(src: string): string {
+	let path = src.replace(/^\//, '');
+	path = path.replace(/\.(tsx?|jsx?|vue|svelte)$/, '');
+	path = path.replace(/\.(solid|react|lit|preact)$/, '');
+
+	const nestedMatch = new RegExp(/^src\/(.+)\/islands\/([^/]+)$/).exec(path);
+	if (nestedMatch) {
+		const [, namespace, name] = nestedMatch;
+		return `${namespace}/${name}`;
+	}
+
+	const defaultMatch = new RegExp(/^(?:src\/)?islands\/([^/]+)$/).exec(path);
+	if (defaultMatch) {
+		return defaultMatch[1];
+	}
+
+	return path;
+}
+
+/**
+ * Get island entry by qualified name or simple name
+ */
+export function getIslandEntry(
+	nameOrQualified: string,
+	manifest: ExtendedIslandManifest | IslandManifest,
+): ExtendedIslandEntry | IslandEntry | null {
+	if (manifest.islands[nameOrQualified]) {
+		return manifest.islands[nameOrQualified];
+	}
+
+	const extendedManifest = manifest as ExtendedIslandManifest;
+	if (extendedManifest.directories) {
+		for (const [qualifiedName, entry] of Object.entries(manifest.islands)) {
+			const simpleName = qualifiedName.split('/').pop();
+			if (simpleName === nameOrQualified) {
+				return entry;
+			}
+		}
+	}
+
+	return null;
+}