bertui 1.0.3 → 1.1.1

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

@@ -0,0 +1,58 @@
+// 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

@@ -0,0 +1,63 @@
+// bertui/src/build/sitemap-generator.js - SIMPLIFIED
+import { join } from 'path';
+import logger from '../../logger/logger';
+
+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/processors/asset-processor.js

@@ -0,0 +1,19 @@
+// 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

@@ -0,0 +1,35 @@
+// bertui/src/build/processors/css-builder.js
+import { join } from 'path';
+import { existsSync, readdirSync, mkdirSync } from 'fs';
+import logger from '../../logger/logger.js';
+import { buildCSS } from '../css-builder.js';
+
+export async function buildAllCSS(root, outDir) {
+  const srcStylesDir = join(root, 'src', 'styles');
+  const stylesOutDir = join(outDir, 'styles');
+  
+  mkdirSync(stylesOutDir, { recursive: true });
+  
+  if (existsSync(srcStylesDir)) {
+    const cssFiles = readdirSync(srcStylesDir).filter(f => f.endsWith('.css'));
+    
+    if (cssFiles.length === 0) {
+      await Bun.write(join(stylesOutDir, 'bertui.min.css'), '/* No CSS */');
+      return;
+    }
+    
+    let combinedCSS = '';
+    for (const cssFile of cssFiles) {
+      const srcPath = join(srcStylesDir, cssFile);
+      const file = Bun.file(srcPath);
+      const cssContent = await file.text();
+      combinedCSS += `/* ${cssFile} */\n${cssContent}\n\n`;
+    }
+    
+    const combinedPath = join(stylesOutDir, 'bertui.min.css');
+    await Bun.write(combinedPath, combinedCSS);
+    await buildCSS(combinedPath, combinedPath);
+    
+    logger.success(`✅ Combined ${cssFiles.length} CSS files`);
+  }
+}

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

@@ -0,0 +1,156 @@
+// bertui/src/build/server-island-validator.js
+// Fixed validation for Server Islands - no false positives!
+
+import logger from '../logger/logger.js';
+
+/**
+ * Validates that a Server Island component follows all rules
+ * @param {string} sourceCode - The component source code
+ * @param {string} filePath - Path to the file (for error messages)
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateServerIsland(sourceCode, filePath) {
+  const errors = [];
+  
+  // Rule 1: No React hooks (FIXED: only match actual function calls)
+  const hookPatterns = [
+    'useState',
+    'useEffect',
+    'useContext',
+    'useReducer',
+    'useCallback',
+    'useMemo',
+    'useRef',
+    'useImperativeHandle',
+    'useLayoutEffect',
+    'useDebugValue',
+    'useId',
+    'useDeferredValue',
+    'useTransition',
+    'useSyncExternalStore'
+  ];
+  
+  for (const hook of hookPatterns) {
+    // FIXED: Only match hooks as function calls, not in text/comments
+    // Looks for: useState( or const [x] = useState(
+    const regex = new RegExp(`\\b${hook}\\s*\\(`, 'g');
+    if (regex.test(sourceCode)) {
+      errors.push(`❌ Uses React hook: ${hook}`);
+    }
+  }
+  
+  // Rule 2: No bertui/router imports
+  if (sourceCode.includes('from \'bertui/router\'') || 
+      sourceCode.includes('from "bertui/router"')) {
+    errors.push('❌ Imports from \'bertui/router\' (use <a> tags instead of Link)');
+  }
+  
+  // Rule 3: No browser APIs (FIXED: only match actual usage, not in strings/comments)
+  const browserAPIs = [
+    { pattern: 'window\\.', name: 'window' },
+    { pattern: 'document\\.', name: 'document' },
+    { pattern: 'localStorage\\.', name: 'localStorage' },
+    { pattern: 'sessionStorage\\.', name: 'sessionStorage' },
+    { pattern: 'navigator\\.', name: 'navigator' },
+    { pattern: 'location\\.', name: 'location' },
+    { pattern: 'history\\.', name: 'history' },
+    { pattern: '(?<!//.*|/\\*.*|\\*)\\bfetch\\s*\\(', name: 'fetch' },
+    { pattern: '\\.addEventListener\\s*\\(', name: 'addEventListener' },
+    { pattern: '\\.removeEventListener\\s*\\(', name: 'removeEventListener' },
+    { pattern: '\\bsetTimeout\\s*\\(', name: 'setTimeout' },
+    { pattern: '\\bsetInterval\\s*\\(', name: 'setInterval' },
+    { pattern: '\\brequestAnimationFrame\\s*\\(', name: 'requestAnimationFrame' }
+  ];
+  
+  for (const api of browserAPIs) {
+    const regex = new RegExp(api.pattern, 'g');
+    if (regex.test(sourceCode)) {
+      if (api.name === 'console') {
+        logger.warn(`⚠️  ${filePath} uses console.log (will not work in static HTML)`);
+      } else {
+        errors.push(`❌ Uses browser API: ${api.name}`);
+      }
+    }
+  }
+  
+  // Rule 4: No event handlers (these won't work without JS)
+  const eventHandlers = [
+    'onClick=',
+    'onChange=',
+    'onSubmit=',
+    'onInput=',
+    'onFocus=',
+    'onBlur=',
+    'onMouseEnter=',
+    'onMouseLeave=',
+    'onKeyDown=',
+    'onKeyUp=',
+    'onScroll='
+  ];
+  
+  for (const handler of eventHandlers) {
+    if (sourceCode.includes(handler)) {
+      errors.push(`❌ Uses event handler: ${handler.replace('=', '')} (Server Islands are static HTML)`);
+    }
+  }
+  
+  // Rule 5: Check for dynamic imports
+  if (/import\s*\(/.test(sourceCode)) {
+    errors.push('❌ Uses dynamic import() (not supported in Server Islands)');
+  }
+  
+  // Rule 6: Check for async/await (usually indicates API calls)
+  if (/async\s+function|async\s*\(|async\s+\w+\s*\(/.test(sourceCode)) {
+    errors.push('❌ Uses async/await (Server Islands must be synchronous)');
+  }
+  
+  const valid = errors.length === 0;
+  
+  return { valid, errors };
+}
+
+/**
+ * Display validation errors in a clear format
+ */
+export function displayValidationErrors(filePath, errors) {
+  logger.error(`\n🏝️  Server Island validation failed: ${filePath}`);
+  logger.error('\nViolations:');
+  errors.forEach(error => logger.error(`  ${error}`));
+  logger.error('\n📖 Server Island Rules:');
+  logger.error('  ✅ Pure static JSX only');
+  logger.error('  ❌ No React hooks (useState, useEffect, etc.)');
+  logger.error('  ❌ No Link component (use <a> tags)');
+  logger.error('  ❌ No browser APIs (window, document, fetch)');
+  logger.error('  ❌ No event handlers (onClick, onChange, etc.)');
+  logger.error('\n💡 Tip: Remove the "export const render = \\"server\\"" line');
+  logger.error('   if you need these features (page will be client-only).\n');
+}
+
+/**
+ * Extract and validate all Server Islands in a project
+ */
+export async function validateAllServerIslands(routes) {
+  const serverIslands = [];
+  const validationResults = [];
+  
+  for (const route of routes) {
+    const sourceCode = await Bun.file(route.path).text();
+    const isServerIsland = sourceCode.includes('export const render = "server"');
+    
+    if (isServerIsland) {
+      const validation = validateServerIsland(sourceCode, route.path);
+      
+      validationResults.push({
+        route: route.route,
+        path: route.path,
+        ...validation
+      });
+      
+      if (validation.valid) {
+        serverIslands.push(route);
+      }
+    }
+  }
+  
+  return { serverIslands, validationResults };
+}