bertui 1.2.8 → 2.0.0

package/src/build/compiler/index.js

@@ -1,31 +0,0 @@
-// bertui/src/build/compiler/index.js
-import { join } from 'path';
-import { existsSync } from 'fs';
-import logger from '../../logger/logger.js';
-import { discoverRoutes } from './route-discoverer.js';
-import { compileBuildDirectory } from './file-transpiler.js';
-import { generateBuildRouter } from './router-generator.js';
-
-export async function compileForBuild(root, buildDir, envVars, config = {}) {
-  const srcDir   = join(root, 'src');
-  const pagesDir = join(srcDir, 'pages');
-
-  if (!existsSync(srcDir)) {
-    throw new Error('src/ directory not found!');
-  }
-
-  const importhow = config.importhow || {};
-  let routes = [];
-
-  if (existsSync(pagesDir)) {
-    routes = await discoverRoutes(pagesDir);
-  }
-
-  await compileBuildDirectory(srcDir, buildDir, root, envVars, importhow);
-
-  if (routes.length > 0) {
-    await generateBuildRouter(routes, buildDir);
-  }
-
-  return { routes };
-}

package/src/build/compiler/route-discoverer.js

@@ -1,49 +0,0 @@
-// bertui/src/build/compiler/route-discoverer.js
-import { join, extname } from 'path';
-import { readdirSync, statSync } from 'fs';
-
-export async function discoverRoutes(pagesDir) {
-  const routes = [];
-  
-  async function scanDirectory(dir, basePath = '') {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      const relativePath = join(basePath, entry.name);
-      
-      if (entry.isDirectory()) {
-        await scanDirectory(fullPath, relativePath);
-      } else if (entry.isFile()) {
-        const ext = extname(entry.name);
-        if (ext === '.css') continue;
-        
-        if (['.jsx', '.tsx', '.js', '.ts'].includes(ext)) {
-          const fileName = entry.name.replace(ext, '');
-
-          // Only loading is reserved - index is a valid route (becomes /)
-          if (fileName === 'loading') continue;
-
-          let route = '/' + relativePath.replace(/\\/g, '/').replace(ext, '');
-          if (fileName === 'index') {
-            route = route.replace('/index', '') || '/';
-          }
-          
-          const isDynamic = fileName.includes('[') && fileName.includes(']');
-          
-          routes.push({
-            route: route === '' ? '/' : route,
-            file: relativePath.replace(/\\/g, '/'),
-            path: fullPath,
-            type: isDynamic ? 'dynamic' : 'static'
-          });
-        }
-      }
-    }
-  }
-  
-  await scanDirectory(pagesDir);
-  routes.sort((a, b) => a.type === b.type ? a.route.localeCompare(b.route) : a.type === 'static' ? -1 : 1);
-  
-  return routes;
-}

package/src/build/compiler/router-generator.js

@@ -1,105 +0,0 @@
-// bertui/src/build/compiler/router-generator.js
-import { join } from 'path';
-
-export async function generateBuildRouter(routes, buildDir) {
-  const imports = routes.map((route, i) => {
-    const componentName = `Page${i}`;
-    const importPath = `./pages/${route.file.replace(/\.(jsx|tsx|ts)$/, '.js')}`;
-    return `import ${componentName} from '${importPath}';`;
-  }).join('\n');
-
-  const routeConfigs = routes.map((route, i) => {
-    const componentName = `Page${i}`;
-    return `  { path: '${route.route}', component: ${componentName}, type: '${route.type}' }`;
-  }).join(',\n');
-
-  const routerCode = `import React, { useState, useEffect, createContext, useContext } from 'react';
-
-const RouterContext = createContext(null);
-
-export function useRouter() {
-  const context = useContext(RouterContext);
-  if (!context) throw new Error('useRouter must be used within a Router');
-  return context;
-}
-
-export function Router({ routes }) {
-  const [currentRoute, setCurrentRoute] = useState(null);
-  const [params, setParams] = useState({});
-
-  useEffect(() => {
-    matchAndSetRoute(window.location.pathname);
-    const handlePopState = () => matchAndSetRoute(window.location.pathname);
-    window.addEventListener('popstate', handlePopState);
-    return () => window.removeEventListener('popstate', handlePopState);
-  }, [routes]);
-
-  function matchAndSetRoute(pathname) {
-    for (const route of routes) {
-      if (route.type === 'static' && route.path === pathname) {
-        setCurrentRoute(route);
-        setParams({});
-        return;
-      }
-    }
-    for (const route of routes) {
-      if (route.type === 'dynamic') {
-        const pattern = route.path.replace(/\\[([^\\]]+)\\]/g, '([^/]+)');
-        const regex = new RegExp('^' + pattern + '$');
-        const match = pathname.match(regex);
-        if (match) {
-          const paramNames = [...route.path.matchAll(/\\[([^\\]]+)\\]/g)].map(m => m[1]);
-          const extractedParams = {};
-          paramNames.forEach((name, i) => { extractedParams[name] = match[i + 1]; });
-          setCurrentRoute(route);
-          setParams(extractedParams);
-          return;
-        }
-      }
-    }
-    setCurrentRoute(null);
-    setParams({});
-  }
-
-  function navigate(path) {
-    window.history.pushState({}, '', path);
-    matchAndSetRoute(path);
-  }
-
-  const Component = currentRoute?.component;
-  return React.createElement(
-    RouterContext.Provider,
-    { value: { currentRoute, params, navigate, pathname: window.location.pathname } },
-    Component ? React.createElement(Component, { params }) : React.createElement(NotFound)
-  );
-}
-
-export function Link({ to, children, ...props }) {
-  const { navigate } = useRouter();
-  return React.createElement('a', {
-    href: to,
-    onClick: (e) => { e.preventDefault(); navigate(to); },
-    ...props
-  }, children);
-}
-
-function NotFound() {
-  return React.createElement('div', {
-    style: { display: 'flex', flexDirection: 'column', alignItems: 'center',
-             justifyContent: 'center', minHeight: '100vh', fontFamily: 'system-ui' }
-  },
-    React.createElement('h1', { style: { fontSize: '6rem', margin: 0 } }, '404'),
-    React.createElement('p', { style: { fontSize: '1.5rem', color: '#666' } }, 'Page not found'),
-    React.createElement('a', { href: '/', style: { color: '#10b981', textDecoration: 'none' } }, 'Go home')
-  );
-}
-
-${imports}
-
-export const routes = [
-${routeConfigs}
-];
-`;
-
-  await Bun.write(join(buildDir, 'router.js'), routerCode);
-}

package/src/build/css-builder.js

@@ -1,81 +0,0 @@
-import { join } from 'path';
-import { existsSync, mkdirSync } from 'fs';
-import { transform } from 'lightningcss';
-import logger from '../logger/logger.js';
-
-/**
- * Build and minify CSS for production using Lightning CSS
- * @param {string} srcPath - Source CSS file path
- * @param {string} destPath - Destination CSS file path
- */
-export async function buildCSS(srcPath, destPath) {
-  try {
-    logger.info(`Processing CSS: ${srcPath.split('/').pop()}`);
-    
-    // Ensure destination directory exists
-    const destDir = join(destPath, '..');
-    if (!existsSync(destDir)) {
-      mkdirSync(destDir, { recursive: true });
-    }
-    
-    // Read source CSS
-    const css = await Bun.file(srcPath).text();
-    const originalSize = Buffer.byteLength(css);
-    
-    // Transform with Lightning CSS (blazing fast)
-    const { code } = transform({
-      filename: srcPath,
-      code: Buffer.from(css),
-      minify: true,
-      sourceMap: false,
-      targets: {
-        // Support last 2 versions of major browsers
-        chrome: 90 << 16,
-        firefox: 88 << 16,
-        safari: 14 << 16,
-        edge: 90 << 16
-      },
-      drafts: {
-        nesting: true // Enable CSS nesting
-      }
-    });
-    
-    // Write minified CSS
-    await Bun.write(destPath, code);
-    
-    // Calculate size reduction
-    const minifiedSize = code.length;
-    const originalKB = (originalSize / 1024).toFixed(2);
-    const minifiedKB = (minifiedSize / 1024).toFixed(2);
-    const reduction = ((1 - minifiedSize / originalSize) * 100).toFixed(1);
-    
-    logger.success(`CSS minified: ${originalKB}KB → ${minifiedKB}KB (-${reduction}%)`);
-    
-    return { success: true, size: minifiedKB };
-  } catch (error) {
-    logger.error(`CSS build failed: ${error.message}`);
-    throw error;
-  }
-}
-
-/**
- * Copy CSS without minification (for dev)
- * @param {string} srcPath - Source CSS file path
- * @param {string} destPath - Destination CSS file path
- */
-export async function copyCSS(srcPath, destPath) {
-  try {
-    const destDir = join(destPath, '..');
-    if (!existsSync(destDir)) {
-      mkdirSync(destDir, { recursive: true });
-    }
-    
-    await Bun.write(destPath, Bun.file(srcPath));
-    logger.info('CSS copied for development');
-    
-    return { success: true };
-  } catch (error) {
-    logger.error(`CSS copy failed: ${error.message}`);
-    throw error;
-  }
-}

package/src/build/generators/html-generator.js

@@ -1,151 +0,0 @@
-// bertui/src/build/generators/html-generator.js
-import { join, relative } from 'path';
-import { mkdirSync, existsSync, cpSync } from 'fs';
-import logger from '../../logger/logger.js';
-import { extractMetaFromSource } from '../../utils/meta-extractor.js';
-
-export async function generateProductionHTML(root, outDir, buildResult, routes, config) {
-  const mainBundle = buildResult.outputs.find(o =>
-    o.path.includes('main') && o.kind === 'entry-point'
-  );
-
-  if (!mainBundle) {
-    logger.error('Could not find main bundle');
-    return;
-  }
-
-  const bundlePath = relative(outDir, mainBundle.path).replace(/\\/g, '/');
-  const defaultMeta = config.meta || {};
-  const bertuiPackages = await copyBertuiPackagesToProduction(root, outDir);
-
-  logger.info(`Generating HTML for ${routes.length} routes...`);
-
-  for (const route of routes) {
-    await processSingleRoute(route, config, defaultMeta, bundlePath, outDir, bertuiPackages);
-  }
-
-  logger.success(`HTML generation complete for ${routes.length} routes`);
-}
-
-async function copyBertuiPackagesToProduction(root, outDir) {
-  const nodeModulesDir = join(root, 'node_modules');
-  const packages = { bertuiIcons: false, bertuiAnimate: false, elysiaEden: false };
-
-  if (!existsSync(nodeModulesDir)) return packages;
-
-  const bertuiIconsSource = join(nodeModulesDir, 'bertui-icons');
-  if (existsSync(bertuiIconsSource)) {
-    try {
-      const bertuiIconsDest = join(outDir, 'node_modules', 'bertui-icons');
-      mkdirSync(join(outDir, 'node_modules'), { recursive: true });
-      cpSync(bertuiIconsSource, bertuiIconsDest, { recursive: true });
-      packages.bertuiIcons = true;
-    } catch (error) {
-      logger.error(`Failed to copy bertui-icons: ${error.message}`);
-    }
-  }
-
-  const bertuiAnimateSource = join(nodeModulesDir, 'bertui-animate', 'dist');
-  if (existsSync(bertuiAnimateSource)) {
-    try {
-      const bertuiAnimateDest = join(outDir, 'css');
-      mkdirSync(bertuiAnimateDest, { recursive: true });
-      const minCSSPath = join(bertuiAnimateSource, 'bertui-animate.min.css');
-      if (existsSync(minCSSPath)) {
-        cpSync(minCSSPath, join(bertuiAnimateDest, 'bertui-animate.min.css'));
-        packages.bertuiAnimate = true;
-      }
-    } catch (error) {
-      logger.error(`Failed to copy bertui-animate: ${error.message}`);
-    }
-  }
-
-  const elysiaEdenSource = join(nodeModulesDir, '@elysiajs', 'eden');
-  if (existsSync(elysiaEdenSource)) {
-    try {
-      const elysiaEdenDest = join(outDir, 'node_modules', '@elysiajs', 'eden');
-      mkdirSync(join(outDir, 'node_modules', '@elysiajs'), { recursive: true });
-      cpSync(elysiaEdenSource, elysiaEdenDest, { recursive: true });
-      packages.elysiaEden = true;
-    } catch (error) {
-      logger.error(`Failed to copy @elysiajs/eden: ${error.message}`);
-    }
-  }
-
-  return packages;
-}
-
-async function processSingleRoute(route, config, defaultMeta, bundlePath, outDir, bertuiPackages) {
-  try {
-    const sourceCode = await Bun.file(route.path).text();
-    const pageMeta = extractMetaFromSource(sourceCode);
-    const meta = { ...defaultMeta, ...pageMeta };
-
-    const html = generateHTML(meta, bundlePath, bertuiPackages);
-
-    let htmlPath;
-    if (route.route === '/') {
-      htmlPath = join(outDir, 'index.html');
-    } else {
-      const routeDir = join(outDir, route.route.replace(/^\//, ''));
-      mkdirSync(routeDir, { recursive: true });
-      htmlPath = join(routeDir, 'index.html');
-    }
-
-    await Bun.write(htmlPath, html);
-    logger.success(`${route.route}`);
-
-  } catch (error) {
-    logger.error(`Failed HTML for ${route.route}: ${error.message}`);
-  }
-}
-
-function generateHTML(meta, bundlePath, bertuiPackages = {}) {
-  const bertuiIconsImport = bertuiPackages.bertuiIcons
-    ? ',\n      "bertui-icons": "/node_modules/bertui-icons/generated/index.js"'
-    : '';
-
-  const bertuiAnimateCSS = bertuiPackages.bertuiAnimate
-    ? '  <link rel="stylesheet" href="/css/bertui-animate.min.css">'
-    : '';
-
-  const elysiaEdenImport = bertuiPackages.elysiaEden
-    ? ',\n      "@elysiajs/eden": "/node_modules/@elysiajs/eden/dist/index.mjs"'
-    : '';
-
-  return `<!DOCTYPE html>
-<html lang="${meta.lang || 'en'}">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${meta.title || 'BertUI App'}</title>
-  <meta name="description" content="${meta.description || 'Built with BertUI'}">
-  ${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}">` : ''}
-  <link rel="stylesheet" href="/styles/bertui.min.css">
-${bertuiAnimateCSS}
-  <link rel="icon" type="image/svg+xml" href="/favicon.svg">
-  <script type="importmap">
-  {
-    "imports": {
-      "react": "https://esm.sh/react@18.2.0",
-      "react-dom": "https://esm.sh/react-dom@18.2.0",
-      "react-dom/client": "https://esm.sh/react-dom@18.2.0/client",
-      "react/jsx-runtime": "https://esm.sh/react@18.2.0/jsx-runtime",
-      "react/jsx-dev-runtime": "https://esm.sh/react@18.2.0/jsx-dev-runtime",
-      "@bunnyx/api": "/bunnyx-api/api-client.js",
-      "@elysiajs/eden": "/node_modules/@elysiajs/eden/dist/index.mjs"${bertuiIconsImport}${elysiaEdenImport}
-    }
-  }
-  </script>
-</head>
-<body>
-  <div id="root"></div>
-  <script type="module" src="/${bundlePath}"></script>
-</body>
-</html>`;
-}

package/src/build/generators/robots-generator.js

@@ -1,58 +0,0 @@
-// bertui/src/build/robots-generator.js
-import { join } from 'path';
-import logger from '../../logger/logger.js';
-
-/**
- * Generate robots.txt from sitemap data
- * @param {Object} config - BertUI config with baseUrl
- * @param {string} outDir - Output directory (dist/)
- * @param {Array} routes - Optional: routes to disallow (e.g., admin pages)
- */
-export async function generateRobots(config, outDir, routes = []) {
-  logger.info('🤖 Generating robots.txt...');
-  
-  // ✅ FIX: Check if baseUrl exists, then remove trailing slash
-  if (!config?.baseUrl) {
-    logger.error('❌ baseUrl is required in bertui.config.js for robots.txt generation!');
-    logger.error('   Add: baseUrl: "https://your-domain.com" to your config');
-    throw new Error('Missing baseUrl in config - robots.txt generation failed');
-  }
-  
-  const baseUrl = config.baseUrl.replace(/\/$/, ''); // Remove trailing slash
-  const sitemapUrl = `${baseUrl}/sitemap.xml`;
-  
-  logger.info(`   Sitemap URL: ${sitemapUrl}`);
-  
-  // Default robots.txt - Allow all
-  let robotsTxt = `# BertUI Generated robots.txt
-User-agent: *
-Allow: /
-
-# Sitemap
-Sitemap: ${sitemapUrl}
-`;
-  
-  // Add custom disallow rules if specified in config
-  if (config?.robots?.disallow && Array.isArray(config.robots.disallow) && config.robots.disallow.length > 0) {
-    robotsTxt += '\n# Custom Disallow Rules\n';
-    config.robots.disallow.forEach(path => {
-      robotsTxt += `Disallow: ${path}\n`;
-    });
-    logger.info(`   Blocked ${config.robots.disallow.length} path(s)`);
-  }
-  
-  // Add crawl delay if specified
-  if (config?.robots?.crawlDelay && typeof config.robots.crawlDelay === 'number') {
-    robotsTxt += `\nCrawl-delay: ${config.robots.crawlDelay}\n`;
-    logger.info(`   Crawl delay: ${config.robots.crawlDelay}s`);
-  }
-  
-  // Write to dist/robots.txt
-  const robotsPath = join(outDir, 'robots.txt');
-  await Bun.write(robotsPath, robotsTxt);
-  
-  logger.success('✅ robots.txt generated');
-  logger.info(`   Location: ${robotsPath}`);
-  
-  return { path: robotsPath, content: robotsTxt };
-}

package/src/build/generators/sitemap-generator.js

@@ -1,63 +0,0 @@
-// bertui/src/build/sitemap-generator.js - SIMPLIFIED
-import { join } from 'path';
-import logger from '../../logger/logger.js';
-
-function calculatePriority(route) {
-  if (route === '/') return 1.0;
-  if (route.includes(':')) return 0.6;
-  const depth = route.split('/').filter(Boolean).length;
-  if (depth === 1) return 0.8;
-  if (depth === 2) return 0.7;
-  return 0.6;
-}
-
-function generateSitemapXML(routes, baseUrl) {
-  const urls = routes.map(route => {
-    const url = `${baseUrl}${route.route}`;
-    return `  <url>
-    <loc>${url}</loc>
-    <lastmod>${route.lastmod}</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>${route.priority}</priority>
-  </url>`;
-  }).join('\n');
-  
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urls}
-</urlset>`;
-}
-
-export async function generateSitemap(routes, config, outDir) {
-  logger.info('🗺️  Generating sitemap.xml...');
-  
-  if (!config?.baseUrl) {
-    logger.error('❌ baseUrl is required in bertui.config.js for sitemap generation!');
-    logger.error('   Add: baseUrl: "https://your-domain.com" to your config');
-    throw new Error('Missing baseUrl in config - sitemap generation failed');
-  }
-  
-  const baseUrl = config.baseUrl.replace(/\/$/, '');
-  const currentDate = new Date().toISOString().split('T')[0];
-  
-  logger.info(`   Base URL: ${baseUrl}`);
-  
-  const staticRoutes = routes.filter(r => r.type === 'static');
-  logger.info(`   ${staticRoutes.length} static routes will be included in sitemap`);
-  
-  // SIMPLE: No file reading, just route processing
-  const sitemapRoutes = staticRoutes.map(route => ({
-    route: route.route,
-    lastmod: currentDate,
-    priority: calculatePriority(route.route)
-  }));
-  
-  const xml = generateSitemapXML(sitemapRoutes, baseUrl);
-  const sitemapPath = join(outDir, 'sitemap.xml');
-  await Bun.write(sitemapPath, xml);
-  
-  logger.success(`✅ Sitemap generated: ${sitemapRoutes.length} URLs`);
-  logger.info(`   Location: ${sitemapPath}`);
-  
-  return { routes: sitemapRoutes, path: sitemapPath };
-}

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]}`;
-}