bertui 1.2.9 → 2.0.0

package/src/build/image-optimizer.js

@@ -1,137 +0,0 @@
-// bertui/src/build/image-optimizer.js - UPDATED WITH WASM
-import { join, extname } from 'path';
-import { existsSync, mkdirSync, readdirSync } from 'fs';
-import logger from '../logger/logger.js';
-import { optimizeImage, hasWasm } from '../image-optimizer/index.js';
-import { copyImagesSync } from '../images/index.js';
-
-export async function optimizeImages(srcDir, outDir, options = {}) {
-  const {
-    quality = 80,
-    webpQuality = 75,
-    verbose = false
-  } = options;
-
-  // Check if WASM is available
-  const wasmAvailable = await hasWasm();
-  
-  if (wasmAvailable) {
-    logger.info(`🦀 Optimizing images with Rust WASM (quality: ${quality})...`);
-  } else {
-    logger.info('📋 Copying images (WASM optimizer not available)...');
-  }
-
-  const imageExtensions = [
-    '.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg', 
-    '.avif', '.ico', '.bmp', '.tiff', '.tif'
-  ];
-  
-  let optimized = 0;
-  let copied = 0;
-  let skipped = 0;
-  let totalSaved = 0;
-  const results = [];
-
-  if (!existsSync(srcDir)) {
-    logger.warn(`⚠️  Source not found: ${srcDir}`);
-    return { optimized: 0, copied: 0, saved: 0, results: [] };
-  }
-
-  mkdirSync(outDir, { recursive: true });
-
-  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()) {
-        const subDestPath = join(targetDir, entry.name);
-        mkdirSync(subDestPath, { recursive: true });
-        await processDirectory(srcPath, subDestPath);
-      } else if (entry.isFile()) {
-        const ext = extname(entry.name).toLowerCase();
-        
-        if (imageExtensions.includes(ext)) {
-          try {
-            const file = Bun.file(srcPath);
-            const buffer = await file.arrayBuffer();
-            const originalSize = buffer.byteLength;
-            
-            // Try WASM optimization first, fallback to copy
-            if (wasmAvailable && ['.png', '.jpg', '.jpeg', '.webp'].includes(ext)) {
-              const format = ext.slice(1);
-              const result = await optimizeImage(buffer, {
-                format,
-                quality,
-                webpQuality
-              });
-              
-              await Bun.write(destPath, new Uint8Array(result.data));
-              
-              const saved = originalSize - result.optimized_size;
-              totalSaved += saved;
-              optimized++;
-              
-              results.push({
-                file: entry.name,
-                original: formatBytes(originalSize),
-                optimized: formatBytes(result.optimized_size),
-                saved: formatBytes(saved),
-                percent: result.savings_percent.toFixed(1) + '%'
-              });
-            } else {
-              // Just copy unsupported formats
-              await Bun.write(destPath, file);
-              copied++;
-              results.push({
-                file: entry.name,
-                status: 'copied'
-              });
-            }
-          } catch (error) {
-            logger.warn(`  Failed to process ${entry.name}: ${error.message}`);
-            // Fallback: copy original
-            await Bun.write(destPath, Bun.file(srcPath));
-            copied++;
-          }
-        } else {
-          // Copy non-image files
-          await Bun.write(destPath, Bun.file(srcPath));
-          skipped++;
-        }
-      }
-    }
-  }
-
-  await processDirectory(srcDir, outDir);
-
-  // Show summary
-  if (optimized > 0) {
-    logger.success(`✅ Optimized ${optimized} images with Rust WASM`);
-    logger.table(results.slice(0, 10));
-    if (results.length > 10) {
-      logger.info(`   ... and ${results.length - 10} more images`);
-    }
-    logger.info(`📊 Total saved: ${formatBytes(totalSaved)}`);
-  }
-  
-  if (copied > 0) {
-    logger.info(`📋 Copied ${copied} images (fallback)`);
-  }
-
-  return { optimized, copied, saved: totalSaved, results };
-}
-
-export function copyImages(srcDir, outDir) {
-  return copyImagesSync(srcDir, outDir);
-}
-
-function formatBytes(bytes) {
-  if (bytes === 0) return '0 B';
-  const k = 1024;
-  const sizes = ['B', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
-}

package/src/build/processors/asset-processor.js

@@ -1,19 +0,0 @@
-// bertui/src/build/processors/asset-processor.js
-import { join } from 'path';
-import { existsSync, mkdirSync } from 'fs'; // ✅ ADD THIS IMPORT
-import { copyImages } from '../image-optimizer.js';
-
-export async function copyAllStaticAssets(root, outDir) {
-  const publicDir = join(root, 'public');
-  const srcImagesDir = join(root, 'src', 'images');
-  
-  if (existsSync(publicDir)) {
-    copyImages(publicDir, outDir);
-  }
-  
-  if (existsSync(srcImagesDir)) {
-    const distImagesDir = join(outDir, 'images');
-    mkdirSync(distImagesDir, { recursive: true });
-    copyImages(srcImagesDir, distImagesDir);
-  }
-}

package/src/build/processors/css-builder.js

@@ -1,142 +0,0 @@
-// bertui/src/build/processors/css-builder.js - WITH SCSS + CACHING + CSS MODULES
-import { join } from 'path';
-import { existsSync, readdirSync, mkdirSync } from 'fs';
-import logger from '../../logger/logger.js';
-import { globalCache } from '../../utils/cache.js';
-import { minifyCSS, processSCSS } from '../../css/processor.js';
-
-export async function buildAllCSS(root, outDir) {
-  const startTime = process.hrtime.bigint();
-  
-  const srcStylesDir = join(root, 'src', 'styles');
-  // CSS modules scoped CSS is staged here by file-transpiler.js
-  const modulesStagingDir = join(root, '.bertuibuild', 'styles-staged');
-  const stylesOutDir = join(outDir, 'styles');
-  
-  mkdirSync(stylesOutDir, { recursive: true });
-  
-  const cacheKey = `css-build:${root}:${Date.now()}`;
-  const cached = globalCache.get(cacheKey, { ttl: 1000 });
-  
-  if (cached) {
-    logger.info(`⚡ Using cached CSS (${cached.files} files)`);
-    await Bun.write(join(stylesOutDir, 'bertui.min.css'), cached.content);
-    return;
-  }
-  
-  let combinedCSS = '';
-  let fileCount = 0;
-
-  // 1. Process src/styles/ (plain CSS + SCSS)
-  if (existsSync(srcStylesDir)) {
-    await processSCSSDirectory(srcStylesDir, root);
-    const cssFiles = readdirSync(srcStylesDir).filter(f => f.endsWith('.css') && !f.endsWith('.module.css'));
-
-    logger.info(`Processing ${cssFiles.length} CSS file(s)...`);
-
-    for (const cssFile of cssFiles) {
-      const srcPath = join(srcStylesDir, cssFile);
-      const fileBuffer = await globalCache.getFile(srcPath, { logSpeed: true });
-      if (fileBuffer) {
-        const content = fileBuffer.toString('utf-8');
-        combinedCSS += `/* ${cssFile} */\n${content}\n\n`;
-        fileCount++;
-      }
-    }
-  } else {
-    logger.info('No styles directory found');
-  }
-
-  // 2. Include scoped CSS from CSS modules (staged by file-transpiler.js)
-  if (existsSync(modulesStagingDir)) {
-    const moduleFiles = readdirSync(modulesStagingDir).filter(f => f.endsWith('.css'));
-    if (moduleFiles.length > 0) {
-      logger.info(`Including ${moduleFiles.length} CSS module(s)...`);
-      for (const cssFile of moduleFiles) {
-        const srcPath = join(modulesStagingDir, cssFile);
-        const content = await Bun.file(srcPath).text();
-        combinedCSS += `/* module: ${cssFile} */\n${content}\n\n`;
-        fileCount++;
-      }
-    }
-  }
-
-  if (!combinedCSS.trim()) {
-    await Bun.write(join(stylesOutDir, 'bertui.min.css'), '/* No CSS */');
-    return;
-  }
-
-  const combinedPath = join(stylesOutDir, 'bertui.min.css');
-  
-  const minifyCacheKey = `minify:${Buffer.from(combinedCSS).length}:${combinedCSS.substring(0, 100)}`;
-  let minified = globalCache.get(minifyCacheKey);
-  
-  if (!minified) {
-    minified = await minifyCSS(combinedCSS, {
-      filename: 'bertui.min.css',
-      sourceMap: false
-    });
-    globalCache.set(minifyCacheKey, minified, { ttl: 60000 });
-  }
-  
-  await Bun.write(combinedPath, minified);
-  
-  const originalSize = Buffer.byteLength(combinedCSS);
-  const minifiedSize = Buffer.byteLength(minified);
-  const reduction = ((1 - minifiedSize / originalSize) * 100).toFixed(1);
-  
-  const endTime = process.hrtime.bigint();
-  const duration = Number(endTime - startTime) / 1000;
-  
-  logger.success(`CSS optimized: ${(originalSize/1024).toFixed(2)}KB → ${(minifiedSize/1024).toFixed(2)}KB (-${reduction}%)`);
-  logger.info(`⚡ Processing time: ${duration.toFixed(3)}µs`);
-  
-  globalCache.set(cacheKey, {
-    files: fileCount,
-    content: minified,
-    size: minifiedSize
-  }, { ttl: 5000 });
-}
-
-async function processSCSSDirectory(stylesDir, root) {
-  try {
-    const sass = await import('sass').catch(() => null);
-    if (!sass) return;
-    
-    const files = readdirSync(stylesDir);
-    const scssFiles = files.filter(f => f.endsWith('.scss') || f.endsWith('.sass'));
-    
-    if (scssFiles.length === 0) return;
-    
-    logger.info(`📝 Compiling ${scssFiles.length} SCSS files...`);
-    
-    for (const file of scssFiles) {
-      const srcPath = join(stylesDir, file);
-      const cssPath = join(stylesDir, file.replace(/\.(scss|sass)$/, '.css'));
-      
-      const fileBuffer = await globalCache.getFile(srcPath);
-      const cacheKey = `scss:${file}:${Buffer.from(fileBuffer).length}`;
-      const cached = globalCache.get(cacheKey);
-      
-      if (cached && existsSync(cssPath)) {
-        logger.debug(`⚡ Cached SCSS: ${file} → ${file.replace(/\.(scss|sass)$/, '.css')}`);
-        continue;
-      }
-      
-      const result = sass.compile(srcPath, {
-        style: 'expanded',
-        sourceMap: false,
-        loadPaths: [stylesDir, join(root, 'node_modules')]
-      });
-      
-      await Bun.write(cssPath, result.css);
-      globalCache.set(cacheKey, true, { ttl: 30000 });
-      
-      logger.debug(`   ${file} → ${file.replace(/\.(scss|sass)$/, '.css')}`);
-    }
-    
-    logger.success(`✅ SCSS compilation complete`);
-  } catch (error) {
-    logger.warn(`SCSS processing skipped: ${error.message}`);
-  }
-}

package/src/build/server-island-validator.js

@@ -1,67 +0,0 @@
-// bertui/src/build/server-island-validator.js
-import logger from '../logger/logger.js'
-
-const BANNED_HOOKS = [
-  'useState', 'useEffect', 'useReducer', 'useCallback', 'useMemo',
-  'useRef', 'useContext', 'useLayoutEffect', 'useId',
-  'useImperativeHandle', 'useDebugValue', 'useDeferredValue',
-  'useTransition', 'useSyncExternalStore',
-]
-
-const BANNED_EVENTS = [
-  'onClick', 'onChange', 'onSubmit', 'onInput', 'onFocus',
-  'onBlur', 'onMouseEnter', 'onMouseLeave', 'onKeyDown', 'onKeyUp',
-]
-
-export function validateServerIsland(sourceCode, filePath) {
-  const errors = []
-
-  for (const hook of BANNED_HOOKS) {
-    if (new RegExp(`\\b${hook}\\s*\\(`).test(sourceCode)) {
-      errors.push(`Cannot use React hook "${hook}" in a static/server page — hooks need a browser runtime`)
-    }
-  }
-
-  for (const event of BANNED_EVENTS) {
-    if (sourceCode.includes(`${event}=`)) {
-      errors.push(`Cannot use event handler "${event}" in a static/server page — events need a browser runtime`)
-    }
-  }
-
-  if (/window\.|document\.|localStorage\.|sessionStorage\./.test(sourceCode)) {
-    errors.push('Cannot access browser APIs (window/document/localStorage) in a static/server page')
-  }
-
-  return { valid: errors.length === 0, errors }
-}
-
-export function displayValidationErrors(filePath, errors) {
-  logger.error(`\n❌ Static/Server page validation failed: ${filePath}`)
-  for (const err of errors) {
-    logger.error(`   · ${err}`)
-  }
-  logger.error(`   → Remove the above or switch to default render mode\n`)
-}
-
-export async function validateAllServerIslands(routes) {
-  const serverIslands = []
-  const validationResults = []
-
-  for (const route of routes) {
-    try {
-      const src = await Bun.file(route.path).text()
-      const isStatic = /export\s+const\s+render\s*=\s*["'](server|static)["']/.test(src)
-      if (!isStatic) continue
-
-      const result = validateServerIsland(src, route.path)
-      serverIslands.push(route)
-      validationResults.push({ ...result, route: route.route, path: route.path })
-
-      if (!result.valid) {
-        displayValidationErrors(route.path, result.errors)
-      }
-    } catch {}
-  }
-
-  return { serverIslands, validationResults }
-}

package/src/build/ssr-renderer.js

@@ -1,64 +0,0 @@
-// bertui/src/build/ssr-renderer.js
-import { join } from 'path'
-import { existsSync, mkdirSync, rmSync } from 'fs'
-import logger from '../logger/logger.js'
-
-/**
- * Render a static page to HTML string using renderToString.
- * Forces both the page and renderToString to use the same React
- * instance from the project's own node_modules.
- */
-export async function renderPageToHTML(compiledPagePath, buildDir) {
-  try {
-    // Extract project root from compiled path
-    // e.g. /project/.bertuibuild/pages/about.js → /project/
-    const projectRoot = compiledPagePath.split('.bertuibuild')[0]
-
-    // Explicitly resolve React from the PROJECT's node_modules
-    // This prevents the two-React-instances problem when bertui is bun linked
-    const reactPath         = join(projectRoot, 'node_modules', 'react', 'index.js')
-    const reactDomServerPath = join(projectRoot, 'node_modules', 'react-dom', 'server.js')
-
-    if (!existsSync(reactPath)) {
-      logger.warn(`React not found in project node_modules: ${reactPath}`)
-      return null
-    }
-
-    if (!existsSync(reactDomServerPath)) {
-      logger.warn(`react-dom/server not found in project node_modules: ${reactDomServerPath}`)
-      return null
-    }
-
-    const React            = await import(reactPath)
-    const { renderToString } = await import(reactDomServerPath)
-
-    // Import the compiled page
-    const mod = await import(`${compiledPagePath}?t=${Date.now()}`)
-    const Component = mod.default
-
-    if (typeof Component !== 'function') {
-      logger.warn(`No default export found in ${compiledPagePath}`)
-      return null
-    }
-
-    return renderToString(React.createElement(Component))
-
-  } catch (err) {
-    logger.warn(`renderToString failed for ${compiledPagePath}: ${err.message}`)
-    return null
-  }
-}
-
-/**
- * Check if a route's source file has render = "server" or render = "static"
- */
-export async function getPageRenderMode(sourcePath) {
-  try {
-    const src = await Bun.file(sourcePath).text()
-    if (/export\s+const\s+render\s*=\s*["']server["']/.test(src)) return 'server'
-    if (/export\s+const\s+render\s*=\s*["']static["']/.test(src)) return 'static'
-    return 'default'
-  } catch {
-    return 'default'
-  }
-}