@useavalon/avalon 0.1.13 → 0.1.14

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

@@ -1,116 +0,0 @@
-import type { Plugin } from 'vite';
-import { resolve } from 'node:path';
-import { getOptimizeDepsForIntegrations, getSSRNoExternalForIntegrations } from './integration-config.ts';
-
-export interface IntegrationBundlerOptions {
-	/** Integrations to include in the build */
-	integrations: string[];
-	/** Whether to bundle for SSR */
-	ssr?: boolean;
-}
-
-/**
- * Vite plugin to bundle integration packages
- * Ensures integration server and client code is properly bundled
- */
-export function integrationBundlerPlugin(options: IntegrationBundlerOptions): Plugin {
-	const { integrations, ssr = false } = options;
-	const cwd = process.cwd();
-
-	return {
-		name: 'avalon:integration-bundler',
-		enforce: 'post',
-
-		config(config) {
-			// Add integration entry points to the build
-			const entries: Record<string, string> = {};
-			
-			for (const framework of integrations) {
-				if (ssr) {
-					// SSR build: include server-side integration code
-					entries[`integrations/${framework}/server`] = resolve(
-						cwd,
-						`packages/integrations/${framework}/server/renderer.ts`
-					);
-				} else {
-					// Client build: include client-side integration code
-					entries[`integrations/${framework}/client`] = resolve(
-						cwd,
-						`packages/integrations/${framework}/client/index.ts`
-					);
-				}
-			}
-
-			// Merge with existing rolldown input
-			const existingInput = config.build?.rolldownOptions?.input || {};
-			const mergedInput = typeof existingInput === 'string' 
-				? { main: existingInput, ...entries }
-				: { ...existingInput, ...entries };
-
-			return {
-				build: {
-					rolldownOptions: {
-						input: mergedInput,
-					},
-				},
-			};
-		},
-
-
-	};
-}
-
-/**
- * Get external dependencies for integration bundling
- * These should not be bundled but loaded from node_modules
- */
-export function getIntegrationExternals(framework: string, ssr: boolean) {
-	const externals: string[] = [];
-
-	// Framework-specific externals
-	switch (framework) {
-		case 'preact':
-			if (!ssr) {
-				// Client-side: preact should be bundled for hydration
-				return [];
-			}
-			// SSR: keep preact external if needed
-			externals.push('preact', 'preact/hooks', 'preact-render-to-string');
-			break;
-
-		case 'vue':
-			if (ssr) {
-				// SSR: Vue server renderer should be external
-				externals.push('vue', 'vue/server-renderer', '@vue/server-renderer', '@vue/shared');
-			}
-			break;
-
-		case 'solid':
-			if (ssr) {
-				externals.push('solid-js', 'solid-js/web');
-			}
-			break;
-
-		case 'svelte':
-			if (ssr) {
-				externals.push('svelte', 'svelte/server', 'svelte/compiler', 'svelte/internal');
-			}
-			break;
-	}
-
-	return externals;
-}
-
-/**
- * Configure optimization for integration dependencies
- */
-export function getIntegrationOptimizeDeps(integrations: string[]) {
-	return getOptimizeDepsForIntegrations(integrations);
-}
-
-/**
- * Get SSR noExternal packages for integrations
- */
-export function getIntegrationSSRNoExternal(integrations: string[]) {
-	return getSSRNoExternalForIntegrations(integrations);
-}

package/src/build/integration-config.ts

@@ -1,168 +0,0 @@
-/**
- * Integration configuration for build system
- * Defines how each integration should be bundled and optimized
- */
-
-export interface IntegrationBuildConfig {
-	/** Framework name */
-	name: string;
-	/** File extensions this integration handles */
-	extensions: string[];
-	/** NPM packages that should be optimized for this integration */
-	optimizeDeps: string[];
-	/** NPM packages that should be external in SSR builds */
-	ssrExternal: string[];
-	/** NPM packages that should NOT be external in SSR builds */
-	ssrNoExternal: string[];
-	/** Whether this integration requires a Vite plugin */
-	requiresPlugin: boolean;
-	/** Plugin package name (if requiresPlugin is true) */
-	pluginPackage?: string;
-}
-
-/**
- * Build configuration for all supported integrations
- */
-export const INTEGRATION_BUILD_CONFIGS: Record<string, IntegrationBuildConfig> = {
-	preact: {
-		name: 'preact',
-		extensions: ['.tsx', '.jsx'],
-		optimizeDeps: [
-			'preact',
-			'preact/hooks',
-			'preact/jsx-runtime',
-			'preact/jsx-dev-runtime',
-		],
-		ssrExternal: [],
-		ssrNoExternal: ['preact', 'preact-render-to-string'],
-		requiresPlugin: false,
-	},
-
-	vue: {
-		name: 'vue',
-		extensions: ['.vue'],
-		optimizeDeps: ['vue'],
-		ssrExternal: [],
-		ssrNoExternal: ['vue', '@vue/server-renderer', '@vue/shared'],
-		requiresPlugin: true,
-		pluginPackage: '@vitejs/plugin-vue',
-	},
-
-	solid: {
-		name: 'solid',
-		extensions: ['.tsx', '.jsx'],
-		optimizeDeps: [
-			'solid-js',
-			'solid-js/web',
-			'solid-js/store',
-		],
-		ssrExternal: [],
-		ssrNoExternal: ['solid-js', 'solid-js/web', 'solid-js/store'],
-		requiresPlugin: true,
-		pluginPackage: 'vite-plugin-solid',
-	},
-
-	svelte: {
-		name: 'svelte',
-		extensions: ['.svelte'],
-		optimizeDeps: [
-			'svelte',
-			'svelte/internal',
-			'svelte/store',
-			'svelte/animate',
-			'svelte/easing',
-			'svelte/motion',
-			'svelte/transition',
-		],
-		ssrExternal: [],
-		ssrNoExternal: ['svelte', 'svelte/server', 'svelte/internal', 'svelte/store'],
-		requiresPlugin: true,
-		pluginPackage: '@sveltejs/vite-plugin-svelte',
-	},
-
-	react: {
-		name: 'react',
-		extensions: ['.jsx', '.tsx'],
-		optimizeDeps: [
-			'react',
-			'react/jsx-runtime',
-			'react/jsx-dev-runtime',
-			'react-dom',
-			'react-dom/client',
-		],
-		ssrExternal: [],
-		ssrNoExternal: ['react', 'react-dom', 'react-dom/server'],
-		requiresPlugin: true,
-		pluginPackage: '@vitejs/plugin-react',
-	},
-
-	lit: {
-		name: 'lit',
-		extensions: ['.ts', '.js'],
-		optimizeDeps: [
-			'lit',
-			'lit/decorators.js',
-			'lit/directives/class-map.js',
-			'lit/directives/style-map.js',
-			'@lit/reactive-element',
-		],
-		ssrExternal: [],
-		ssrNoExternal: ['lit', '@lit-labs/ssr', '@lit/reactive-element', 'lit-html'],
-		requiresPlugin: false,
-	},
-};
-
-/**
- * Get build configuration for a specific integration
- */
-export function getIntegrationBuildConfig(framework: string) {
-	return INTEGRATION_BUILD_CONFIGS[framework];
-}
-
-/**
- * Get all optimize deps for given integrations
- */
-export function getOptimizeDepsForIntegrations(integrations: string[]) {
-	const deps = new Set<string>();
-	
-	for (const integration of integrations) {
-		const config = INTEGRATION_BUILD_CONFIGS[integration];
-		if (config) {
-			config.optimizeDeps.forEach(dep => deps.add(dep));
-		}
-	}
-	
-	return Array.from(deps);
-}
-
-/**
- * Get SSR noExternal packages for given integrations
- */
-export function getSSRNoExternalForIntegrations(integrations: string[]) {
-	const packages = new Set<string>();
-	
-	for (const integration of integrations) {
-		const config = INTEGRATION_BUILD_CONFIGS[integration];
-		if (config) {
-			config.ssrNoExternal.forEach(pkg => packages.add(pkg));
-		}
-	}
-	
-	return Array.from(packages);
-}
-
-/**
- * Check if an integration requires a Vite plugin
- */
-export function integrationRequiresPlugin(framework: string) {
-	const config = INTEGRATION_BUILD_CONFIGS[framework];
-	return config?.requiresPlugin ?? false;
-}
-
-/**
- * Get plugin package name for an integration
- */
-export function getIntegrationPluginPackage(framework: string) {
-	const config = INTEGRATION_BUILD_CONFIGS[framework];
-	return config?.pluginPackage;
-}

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

@@ -1,117 +0,0 @@
-import type { Plugin } from 'vite';
-import { resolve } from 'node:path';
-import { readdir, readFile } from 'node:fs/promises';
-
-export interface IntegrationDetectionResult {
-	preact: boolean;
-	vue: boolean;
-	solid: boolean;
-	svelte: boolean;
-}
-
-/**
- * Vite plugin to detect which framework integrations are used in the project
- * This enables tree-shaking of unused integrations
- */
-export function integrationDetectionPlugin(): Plugin {
-	let detectedIntegrations: IntegrationDetectionResult | null = null;
-
-	return {
-		name: 'avalon:integration-detection',
-		enforce: 'pre',
-
-		async buildStart() {
-			// Detect integrations during build start
-			detectedIntegrations = await detectUsedIntegrations();
-		},
-
-		resolveId(id: string) {
-			// Handle integration imports
-			if (id.startsWith('@useavalon/integration-')) {
-				const framework = id.replace('@useavalon/integration-', '').split('/')[0];
-				
-				// Check if this integration is used
-				if (detectedIntegrations && !detectedIntegrations[framework as keyof IntegrationDetectionResult]) {
-					console.warn(`⚠️ Integration ${framework} is imported but not detected in project files`);
-				}
-				
-				// Resolve to the actual integration path
-				const integrationPath = resolve(process.cwd(), `packages/integrations/${framework}/mod.ts`);
-				return integrationPath;
-			}
-			
-			return null;
-		},
-
-		transform(_code: string, id: string) {
-			// Track integration usage in island files
-			if (id.includes('/islands/') || id.includes('/components/')) {
-				// This helps with dynamic detection during development
-				return null;
-			}
-			
-			return null;
-		},
-	};
-}
-
-/**
- * Detect which framework integrations are actually used in the project
- */
-export async function detectUsedIntegrations() {
-	const result: IntegrationDetectionResult = {
-		preact: false,
-		vue: false,
-		solid: false,
-		svelte: false,
-	};
-
-	const searchDirs = ['islands', 'components', 'src/islands', 'src/components'];
-	const cwd = process.cwd();
-
-	for (const dir of searchDirs) {
-		try {
-			const dirPath = resolve(cwd, dir);
-			const entries = await readdir(dirPath, { withFileTypes: true });
-			for (const entry of entries) {
-				if (!entry.isFile()) continue;
-
-				// Check file extensions
-				if (entry.name.endsWith('.vue')) {
-					result.vue = true;
-				} else if (entry.name.endsWith('.svelte')) {
-					result.svelte = true;
-				} else if (entry.name.endsWith('.tsx') || entry.name.endsWith('.jsx')) {
-					// Read file content to detect framework
-					const filePath = resolve(dirPath, entry.name);
-					const content = await readFile(filePath, 'utf-8');
-					
-					if (content.includes('solid-js')) {
-						result.solid = true;
-					} else {
-						// Default to Preact for JSX/TSX files
-						result.preact = true;
-					}
-				}
-			}
-		} catch {
-			// Directory doesn't exist, continue
-		}
-	}
-
-	return result;
-}
-
-/**
- * Get list of integration packages that should be included in the build
- */
-export function getRequiredIntegrations(detected: IntegrationDetectionResult) {
-	const integrations: string[] = [];
-	
-	if (detected.preact) integrations.push('preact');
-	if (detected.vue) integrations.push('vue');
-	if (detected.solid) integrations.push('solid');
-	if (detected.svelte) integrations.push('svelte');
-	
-	return integrations;
-}

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

@@ -1,90 +0,0 @@
-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'),
-	};
-}