bertui 0.4.4 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bertui",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Lightning-fast React dev server powered by Bun and Elysia",
   "type": "module",
   "main": "./index.js",

package/src/build/image-optimizer.js

@@ -1,216 +1,87 @@
-// bertui/src/build/image-optimizer.js - WASM-POWERED VERSION 🚀
+// bertui/src/build/image-optimizer.js - SIMPLE WORKING VERSION
 import { join, extname } from 'path';
 import { existsSync, mkdirSync, readdirSync, cpSync } from 'fs';
 import logger from '../logger/logger.js';
 
 /**
- * 🎯 WASM-powered image optimization using @jsquash
- * Zero OS dependencies, pure JavaScript, blazing fast!
- */
-
-// Lazy-load WASM modules (only when needed)
-let pngEncode, pngDecode;
-let jpegEncode, jpegDecode;
-let webpEncode, webpDecode;
-
-async function initializePNG() {
-  if (!pngEncode) {
-    const { encode, decode } = await import('@jsquash/png');
-    pngEncode = encode;
-    pngDecode = decode;
-  }
-}
-
-async function initializeJPEG() {
-  if (!jpegEncode) {
-    const { encode, decode } = await import('@jsquash/jpeg');
-    jpegEncode = encode;
-    jpegDecode = decode;
-  }
-}
-
-async function initializeWebP() {
-  if (!webpEncode) {
-    const { encode, decode } = await import('@jsquash/webp');
-    webpEncode = encode;
-    webpDecode = decode;
-  }
-}
-
-/**
- * Optimize images using WASM-powered codecs
- * This is FAST and has ZERO OS dependencies! 🚀
+ * Simple image copying - skip WASM optimization for now
  */
 export async function optimizeImages(srcDir, outDir) {
-  const imageExtensions = ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg'];
-  let optimized = 0;
-  let totalSaved = 0;
-
-  logger.info('🖼️  Optimizing images with WASM codecs...');
-
-  async function processDirectory(dir, targetDir) {
-    const entries = readdirSync(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const srcPath = join(dir, entry.name);
-      const destPath = join(targetDir, entry.name);
-
-      if (entry.isDirectory()) {
-        if (!existsSync(destPath)) {
-          mkdirSync(destPath, { recursive: true });
-        }
-        await processDirectory(srcPath, destPath);
-      } else if (entry.isFile()) {
-        const ext = extname(entry.name).toLowerCase();
-
-        if (imageExtensions.includes(ext)) {
-          try {
-            const result = await optimizeImage(srcPath, destPath);
-            if (result) {
-              optimized++;
-              totalSaved += result.saved;
-              const savedPercent = ((result.saved / result.originalSize) * 100).toFixed(1);
-              logger.debug(
-                `✨ ${entry.name}: ${(result.originalSize / 1024).toFixed(1)}KB → ${(result.newSize / 1024).toFixed(1)}KB (-${savedPercent}%)`
-              );
-            }
-          } catch (error) {
-            logger.warn(`⚠️  Failed to optimize ${entry.name}: ${error.message}`);
-            // Fallback: just copy the file
-            cpSync(srcPath, destPath);
-          }
-        }
-      }
-    }
-  }
-
-  await processDirectory(srcDir, outDir);
-
-  if (optimized > 0) {
-    logger.success(
-      `✅ Optimized ${optimized} images (saved ${(totalSaved / 1024).toFixed(2)}KB total)`
-    );
-  }
-
-  return { optimized, saved: totalSaved };
-}
-
-/**
- * Optimize a single image using WASM codecs
- */
-async function optimizeImage(srcPath, destPath) {
-  const ext = extname(srcPath).toLowerCase();
-  const originalFile = Bun.file(srcPath);
-  const originalSize = originalFile.size;
-
-  try {
-    // For SVG and GIF, just copy (no optimization needed/supported)
-    if (ext === '.svg' || ext === '.gif') {
-      cpSync(srcPath, destPath);
-      return null;
-    }
-
-    // Read the original image
-    const originalBuffer = await originalFile.arrayBuffer();
-
-    let optimizedBuffer;
-
-    if (ext === '.png') {
-      await initializePNG();
-      
-      // Decode → Re-encode with compression
-      const imageData = await pngDecode(originalBuffer);
-      
-      // Encode with oxipng-level compression (quality 85, similar to oxipng -o 2)
-      optimizedBuffer = await pngEncode(imageData, { 
-        quality: 85,
-        effort: 2 // 0-10, higher = better compression but slower
-      });
-      
-    } else if (ext === '.jpg' || ext === '.jpeg') {
-      await initializeJPEG();
-      
-      // Decode → Re-encode with quality 85 (mozjpeg-like quality)
-      const imageData = await jpegDecode(originalBuffer);
-      optimizedBuffer = await jpegEncode(imageData, { quality: 85 });
-      
-    } else if (ext === '.webp') {
-      await initializeWebP();
-      
-      // WebP optimization
-      const imageData = await webpDecode(originalBuffer);
-      optimizedBuffer = await webpEncode(imageData, { quality: 85 });
-    }
-
-    // Only save if we actually reduced the size
-    if (optimizedBuffer && optimizedBuffer.byteLength < originalSize) {
-      await Bun.write(destPath, optimizedBuffer);
-      const saved = originalSize - optimizedBuffer.byteLength;
-      return { saved, originalSize, newSize: optimizedBuffer.byteLength };
-    }
-
-    // If optimization didn't help, just copy the original
-    cpSync(srcPath, destPath);
-    return null;
-    
-  } catch (error) {
-    // If anything fails, just copy the original
-    logger.warn(`Optimization failed for ${srcPath.split('/').pop()}, copying original`);
-    cpSync(srcPath, destPath);
-    return null;
-  }
+  logger.info(`📋 Copying images from ${srcDir} to ${outDir}...`);
+  const copied = copyImages(srcDir, outDir);
+  return { optimized: 0, saved: 0, copied };
 }
 
-/**
- * Check if optimization is available (always true with WASM! 🎉)
- */
 export async function checkOptimizationTools() {
-  try {
-    // Try to import the WASM modules
-    await import('@jsquash/png');
-    await import('@jsquash/jpeg');
-    await import('@jsquash/webp');
-    
-    logger.success('✅ WASM image optimization available');
-    logger.info('📦 Using @jsquash (zero OS dependencies!)');
-    return ['png', 'jpeg', 'webp'];
-  } catch (error) {
-    logger.error('❌ WASM codecs not installed. Run: bun add @jsquash/png @jsquash/jpeg @jsquash/webp');
-    return [];
-  }
+  logger.info('📋 Image optimization disabled (simple mode)');
+  return [];
 }
 
-/**
- * Copy images without optimization (fallback)
- */
 export function copyImages(srcDir, outDir) {
-  const imageExtensions = ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg', '.avif'];
+  const imageExtensions = ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg', '.avif', '.ico'];
   let copied = 0;
 
-  function processDirectory(dir, targetDir) {
-    const entries = readdirSync(dir, { withFileTypes: true });
+  // Check if source directory exists
+  if (!existsSync(srcDir)) {
+    logger.warn(`⚠️  Source directory not found: ${srcDir}`);
+    return 0;
+  }
 
-    for (const entry of entries) {
-      const srcPath = join(dir, entry.name);
-      const destPath = join(targetDir, entry.name);
+  // Create output directory if it doesn't exist
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+    logger.info(`Created directory: ${outDir}`);
+  }
 
-      if (entry.isDirectory()) {
-        if (!existsSync(destPath)) {
-          mkdirSync(destPath, { recursive: true });
-        }
-        processDirectory(srcPath, targetDir);
-      } else if (entry.isFile()) {
-        const ext = extname(entry.name).toLowerCase();
+  function processDirectory(dir, targetDir) {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      
+      if (entries.length === 0) {
+        logger.warn(`Directory empty: ${dir}`);
+        return;
+      }
+
+      for (const entry of entries) {
+        const srcPath = join(dir, entry.name);
+        const destPath = join(targetDir, entry.name);
 
-        if (imageExtensions.includes(ext)) {
-          cpSync(srcPath, destPath);
-          copied++;
+        if (entry.isDirectory()) {
+          // Create subdirectory in target
+          const subDestPath = join(targetDir, entry.name);
+          if (!existsSync(subDestPath)) {
+            mkdirSync(subDestPath, { recursive: true });
+          }
+          processDirectory(srcPath, subDestPath);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name).toLowerCase();
+
+          if (imageExtensions.includes(ext)) {
+            try {
+              cpSync(srcPath, destPath);
+              copied++;
+              logger.debug(`  ✓ ${entry.name}`);
+            } catch (error) {
+              logger.warn(`  ✗ ${entry.name} - ${error.message}`);
+            }
+          } else {
+            logger.debug(`  - ${entry.name} (skipped, not an image)`);
+          }
         }
       }
+    } catch (error) {
+      logger.error(`Error processing directory ${dir}: ${error.message}`);
     }
   }
 
+  logger.info(`Processing ${srcDir}...`);
   processDirectory(srcDir, outDir);
-  logger.info(`📋 Copied ${copied} images without optimization`);
+  
+  if (copied > 0) {
+    logger.success(`✅ Copied ${copied} images to ${outDir}`);
+  } else {
+    logger.warn(`⚠️  No images found in ${srcDir}`);
+  }
+  
   return copied;
 }

package/src/build.js

@@ -1,4 +1,4 @@
-// src/build.js - FIXED VERSION
+// src/build.js - COMPLETELY FIXED VERSION
 import { join, relative, basename, extname, dirname } from 'path';
 import { existsSync, mkdirSync, rmSync, cpSync, readdirSync, statSync } from 'fs';
 import logger from './logger/logger.js';
@@ -13,6 +13,7 @@ export async function buildProduction(options = {}) {
   
   logger.bigLog('BUILDING FOR PRODUCTION', { color: 'green' });
   
+  // Clean up old builds
   if (existsSync(buildDir)) {
     rmSync(buildDir, { recursive: true });
   }
@@ -35,7 +36,7 @@ export async function buildProduction(options = {}) {
     
     logger.info('Step 1: Compiling for production...');
     const { routes } = await compileForBuild(root, buildDir, envVars);
-    logger.success('Production compilation complete');
+    logger.success(`Production compilation complete - ${routes.length} routes`);
     
     logger.info('Step 2: Building CSS with Lightning CSS...');
     await buildAllCSS(root, outDir);
@@ -44,8 +45,8 @@ export async function buildProduction(options = {}) {
     const optimizationTools = await checkOptimizationTools();
     
     logger.info('Step 4: Copying and optimizing static assets...');
-    // ✅ FIX 1: Copy images from BOTH src/images/ and public/
-    await copyAllStaticAssets(root, outDir, optimizationTools.length > 0);
+    // SKIP OPTIMIZATION FOR NOW - JUST COPY
+    await copyAllStaticAssets(root, outDir, false);
     
     logger.info('Step 5: Bundling JavaScript with Bun...');
     const buildEntry = join(buildDir, 'main.js');
@@ -85,22 +86,33 @@ export async function buildProduction(options = {}) {
       process.exit(1);
     }
     
-    logger.success('JavaScript bundled with tree-shaking');
+    logger.success('JavaScript bundled successfully');
     
-    logger.info('Step 6: Generating SEO-optimized HTML files...');
-    // ✅ FIX 2: Generate HTML for ALL routes including index.html
+    // DEBUG: Show what was built
+    logger.info('Built outputs:');
+    result.outputs.forEach((output, i) => {
+      logger.info(`  ${i + 1}. ${relative(outDir, output.path)} (${output.kind})`);
+    });
+    
+    logger.info('Step 6: Generating HTML files...');
+    // ✅ CRITICAL FIX: Generate HTML files
     await generateProductionHTML(root, outDir, result, routes);
     
-    rmSync(buildDir, { recursive: true });
-    logger.info('Cleaned up .bertuibuild/');
+    // Clean up build directory
+    if (existsSync(buildDir)) {
+      rmSync(buildDir, { recursive: true });
+      logger.info('Cleaned up .bertuibuild/');
+    }
     
     const duration = Date.now() - startTime;
     logger.success(`✨ Build complete in ${duration}ms`);
     logger.info(`📦 Output: ${outDir}`);
     
+    // Show build summary
     logger.table(result.outputs.map(o => ({
       file: o.path.replace(outDir, ''),
-      size: `${(o.size / 1024).toFixed(2)} KB`
+      size: `${(o.size / 1024).toFixed(2)} KB`,
+      type: o.kind
     })));
     
     logger.bigLog('READY TO DEPLOY', { color: 'green' });
@@ -108,7 +120,7 @@ export async function buildProduction(options = {}) {
     console.log('  Vercel:  bunx vercel');
     console.log('  Netlify: bunx netlify deploy');
     console.log('\n🔍 Preview locally:\n');
-    console.log('  bun run preview\n');
+    console.log('  cd dist && bun run preview\n');
     
   } catch (error) {
     logger.error(`Build failed: ${error.message}`);
@@ -124,44 +136,30 @@ export async function buildProduction(options = {}) {
   }
 }
 
-// ✅ FIX 3: Enhanced asset copying with proper directory structure
+// ✅ SIMPLE asset copying
 async function copyAllStaticAssets(root, outDir, optimize = true) {
   const publicDir = join(root, 'public');
   const srcImagesDir = join(root, 'src', 'images');
   
-  let assetsCopied = 0;
-  let assetsOptimized = 0;
-  
-  // Create images directory in dist/
-  const distImagesDir = join(outDir, 'images');
-  mkdirSync(distImagesDir, { recursive: true });
+  // ALWAYS use simple copy for now
+  logger.info('Using simple asset copy (optimization disabled)...');
   
   // Copy from public/ to root of dist/
   if (existsSync(publicDir)) {
-    logger.info('Copying public/ assets...');
-    if (optimize) {
-      const result = await optimizeImages(publicDir, outDir);
-      assetsOptimized += result.optimized;
-    } else {
-      assetsCopied += copyImages(publicDir, outDir);
-    }
+    logger.info('📁 Copying public/ directory...');
+    copyImages(publicDir, outDir);
+  } else {
+    logger.info('No public/ directory found');
   }
   
-  // ✅ FIX: Copy from src/images/ to dist/images/
+  // Copy from src/images/ to dist/images/
   if (existsSync(srcImagesDir)) {
-    logger.info('Copying src/images/ to dist/images/...');
-    if (optimize) {
-      const result = await optimizeImages(srcImagesDir, distImagesDir);
-      assetsOptimized += result.optimized;
-    } else {
-      assetsCopied += copyImages(srcImagesDir, distImagesDir);
-    }
-  }
-  
-  if (optimize && assetsOptimized > 0) {
-    logger.success(`🎨 Optimized ${assetsOptimized} images with WASM codecs`);
+    logger.info('🖼️  Copying src/images/ to dist/images/...');
+    const distImagesDir = join(outDir, 'images');
+    mkdirSync(distImagesDir, { recursive: true });
+    copyImages(srcImagesDir, distImagesDir);
   } else {
-    logger.success(`📋 Copied ${assetsCopied} static assets`);
+    logger.info('No src/images/ directory found');
   }
 }
 
@@ -552,63 +550,71 @@ function extractMetaFromSource(code) {
   }
 }
 
-// ✅ FIX 4: Generate proper HTML files with correct meta tags
+// ✅ CRITICAL FIX: Generate HTML files
 async function generateProductionHTML(root, outDir, buildResult, routes) {
+  if (routes.length === 0) {
+    logger.warn('No routes found, skipping HTML generation');
+    return;
+  }
+  
+  logger.info(`Generating HTML files for ${routes.length} routes...`);
+  
+  // Find main JS bundle
   const mainBundle = buildResult.outputs.find(o => 
     o.path.includes('main') && o.kind === 'entry-point'
   );
   
   if (!mainBundle) {
-    throw new Error('Could not find main bundle in build output');
+    logger.error('Could not find main bundle in build output');
+    // List all outputs for debugging
+    logger.info('Available outputs:');
+    buildResult.outputs.forEach((o, i) => {
+      logger.info(`  ${i + 1}. ${o.path} (${o.kind})`);
+    });
+    return;
   }
   
   const bundlePath = relative(outDir, mainBundle.path).replace(/\\/g, '/');
-  logger.info(`Main bundle path: ${bundlePath}`);
-  
-  const srcStylesDir = join(root, 'src', 'styles');
-  let userStylesheets = '';
-  
-  if (existsSync(srcStylesDir)) {
-    const cssFiles = readdirSync(srcStylesDir).filter(f => f.endsWith('.css'));
-    userStylesheets = cssFiles.map(f => 
-      `  <link rel="stylesheet" href="/styles/${f.replace('.css', '.min.css')}">`
-    ).join('\n');
-  }
+  logger.info(`Main bundle: ${bundlePath}`);
   
-  // ✅ Load config for default meta
+  // Load config for default meta
   const { loadConfig } = await import('./config/loadConfig.js');
   const config = await loadConfig(root);
   const defaultMeta = config.meta || {};
   
-  logger.info('Generating SEO-optimized HTML files...');
-  
-  // ✅ FIX: Generate HTML for ALL routes (including dynamic as fallback)
+  // Generate HTML for each route
   for (const route of routes) {
-    const sourceCode = await Bun.file(route.path).text();
-    const pageMeta = extractMetaFromSource(sourceCode);
-    const meta = { ...defaultMeta, ...pageMeta };
-    
-    if (pageMeta) {
-      logger.info(`Extracted meta for ${route.route}: ${JSON.stringify(pageMeta)}`);
-    }
-    
-    const html = generateHTML(meta, route, bundlePath, userStylesheets);
-    
-    let htmlPath;
-    if (route.route === '/') {
-      htmlPath = join(outDir, 'index.html');
-    } else {
-      const routeDir = join(outDir, route.route);
-      mkdirSync(routeDir, { recursive: true });
-      htmlPath = join(routeDir, 'index.html');
+    try {
+      const sourceCode = await Bun.file(route.path).text();
+      const pageMeta = extractMetaFromSource(sourceCode);
+      const meta = { ...defaultMeta, ...pageMeta };
+      
+      const html = generateHTML(meta, route, bundlePath);
+      
+      let htmlPath;
+      if (route.route === '/') {
+        htmlPath = join(outDir, 'index.html');
+      } else {
+        // Create directory for the route
+        const routeDir = join(outDir, route.route.slice(1)); // Remove leading slash
+        mkdirSync(routeDir, { recursive: true });
+        htmlPath = join(routeDir, 'index.html');
+      }
+      
+      await Bun.write(htmlPath, html);
+      logger.success(`Generated: ${route.route === '/' ? 'index.html' : route.route + '/index.html'}`);
+    } catch (error) {
+      logger.error(`Failed to generate HTML for ${route.route}: ${error.message}`);
     }
-    
-    await Bun.write(htmlPath, html);
-    logger.success(`Generated ${route.route === '/' ? 'index.html' : route.route + '/index.html'}`);
   }
 }
 
-function generateHTML(meta, route, bundlePath, userStylesheets) {
+function generateHTML(meta, route, bundlePath) {
+  const cssFiles = ['global.min.css', 'home.min.css'];
+  const stylesheets = cssFiles.map(css => 
+    `  <link rel="stylesheet" href="/styles/${css}">`
+  ).join('\n');
+  
   return `<!DOCTYPE html>
 <html lang="${meta.lang || 'en'}">
 <head>
@@ -619,23 +625,10 @@ function generateHTML(meta, route, bundlePath, userStylesheets) {
   <meta name="description" content="${meta.description || 'Built with BertUI - Lightning fast React development'}">
   ${meta.keywords ? `<meta name="keywords" content="${meta.keywords}">` : ''}
   ${meta.author ? `<meta name="author" content="${meta.author}">` : ''}
-  ${meta.themeColor ? `<meta name="theme-color" content="${meta.themeColor}">` : ''}
-  
-  <meta property="og:title" content="${meta.ogTitle || meta.title || 'BertUI App'}">
-  <meta property="og:description" content="${meta.ogDescription || meta.description || 'Built with BertUI'}">
-  ${meta.ogImage ? `<meta property="og:image" content="${meta.ogImage}">` : ''}
-  <meta property="og:type" content="website">
-  <meta property="og:url" content="${route.route}">
-  
-  <meta name="twitter:card" content="summary_large_image">
-  <meta name="twitter:title" content="${meta.ogTitle || meta.title || 'BertUI App'}">
-  <meta name="twitter:description" content="${meta.ogDescription || meta.description || 'Built with BertUI'}">
-  ${meta.ogImage ? `<meta name="twitter:image" content="${meta.ogImage}">` : ''}
   
   <link rel="icon" type="image/svg+xml" href="/favicon.svg">
-  <link rel="canonical" href="${route.route}">
   
-${userStylesheets}
+${stylesheets}
   
   <script type="importmap">
   {