bertui 1.1.6 → 1.1.7

package/src/compiler/transform.js

@@ -0,0 +1,149 @@
+// bertui/src/compiler/transform.js - NEW FILE
+// PURE JSX/TSX transformation function - NO FILE SYSTEM
+
+/**
+ * Transform JSX/TSX code to JavaScript
+ * @param {string} sourceCode - The source code to transform
+ * @param {Object} options - Transformation options
+ * @param {string} options.loader - 'jsx', 'tsx', 'ts', 'js' (default: 'tsx')
+ * @param {string} options.env - 'development' or 'production' (default: 'development')
+ * @param {boolean} options.addReactImport - Automatically add React import if missing (default: true)
+ * @returns {Promise<string>} Transformed JavaScript code
+ */
+export async function transformJSX(sourceCode, options = {}) {
+  const {
+    loader = 'tsx',
+    env = 'development',
+    addReactImport = true
+  } = options;
+
+  // Skip transformation if it's plain JS without JSX
+  if (loader === 'js' && !sourceCode.includes('React.createElement') && !/<[A-Z]/.test(sourceCode)) {
+    return sourceCode;
+  }
+
+  try {
+    // Create Bun transpiler instance
+    const transpiler = new Bun.Transpiler({
+      loader,
+      target: 'browser',
+      define: {
+        'process.env.NODE_ENV': JSON.stringify(env)
+      },
+      tsconfig: {
+        compilerOptions: {
+          jsx: 'react',
+          jsxFactory: 'React.createElement',
+          jsxFragmentFactory: 'React.Fragment',
+          target: 'ES2020',
+          module: 'ESNext'
+        }
+      }
+    });
+
+    let transformed = await transpiler.transform(sourceCode);
+
+    // Add React import if needed and not already present
+    if (addReactImport && 
+        !transformed.includes('import React') && 
+        !transformed.includes('import * as React') &&
+        (transformed.includes('React.createElement') || transformed.includes('jsx(') || transformed.includes('jsxs('))) {
+      transformed = `import React from 'react';\n${transformed}`;
+    }
+
+    // Clean up any dev JSX references
+    if (env === 'production') {
+      transformed = transformed.replace(/jsxDEV/g, 'jsx');
+    }
+
+    return transformed;
+
+  } catch (error) {
+    throw new Error(`JSX transformation failed: ${error.message}`);
+  }
+}
+
+/**
+ * Synchronous version of transformJSX
+ * Use only when you know the code is small and you need sync execution
+ */
+export function transformJSXSync(sourceCode, options = {}) {
+  const {
+    loader = 'tsx',
+    env = 'development',
+    addReactImport = true
+  } = options;
+
+  try {
+    const transpiler = new Bun.Transpiler({
+      loader,
+      target: 'browser',
+      define: {
+        'process.env.NODE_ENV': JSON.stringify(env)
+      }
+    });
+
+    let transformed = transpiler.transformSync(sourceCode);
+
+    if (addReactImport && 
+        !transformed.includes('import React') && 
+        !transformed.includes('import * as React') &&
+        (transformed.includes('React.createElement') || transformed.includes('jsx('))) {
+      transformed = `import React from 'react';\n${transformed}`;
+    }
+
+    if (env === 'production') {
+      transformed = transformed.replace(/jsxDEV/g, 'jsx');
+    }
+
+    return transformed;
+
+  } catch (error) {
+    throw new Error(`JSX transformation failed: ${error.message}`);
+  }
+}
+
+/**
+ * Check if code contains JSX syntax
+ */
+export function containsJSX(code) {
+  return code.includes('React.createElement') || 
+         code.includes('React.Fragment') ||
+         /<[A-Z]/.test(code) ||
+         code.includes('jsx(') ||
+         code.includes('jsxs(') ||
+         /<[a-z][a-z0-9]*\s/.test(code);
+}
+
+/**
+ * Remove CSS imports from code (for production builds)
+ */
+export function removeCSSImports(code) {
+  return code
+    .replace(/import\s+['"][^'"]*\.css['"];?\s*/g, '')
+    .replace(/import\s+['"]bertui\/styles['"]\s*;?\s*/g, '');
+}
+
+/**
+ * Remove dotenv imports (for browser)
+ */
+export function removeDotenvImports(code) {
+  return code
+    .replace(/import\s+\w+\s+from\s+['"]dotenv['"]\s*;?\s*/g, '')
+    .replace(/import\s+\{[^}]+\}\s+from\s+['"]dotenv['"]\s*;?\s*/g, '')
+    .replace(/\w+\.config\(\s*\)\s*;?\s*/g, '');
+}
+
+/**
+ * Fix relative imports to include .js extension
+ */
+export function fixRelativeImports(code) {
+  const importRegex = /from\s+['"](\.\.?\/[^'"]+?)(?<!\.js|\.jsx|\.ts|\.tsx|\.json)['"]/g;
+  
+  return code.replace(importRegex, (match, path) => {
+    if (path.endsWith('/') || /\.\w+$/.test(path)) {
+      return match;
+    }
+    return `from '${path}.js'`;
+  });
+}

package/src/config/index.js

@@ -0,0 +1,2 @@
+export { loadConfig } from './loadConfig.js';
+export { defaultConfig } from './defaultConfig.js';

package/src/css/index.js

@@ -0,0 +1,46 @@
+// bertui/src/css/index.js - NEW FILE
+// PURE CSS processing - no server
+
+import { transform } from 'lightningcss';
+import logger from '../logger/logger.js';
+
+export async function minifyCSS(css, options = {}) {
+  try {
+    const { code } = transform({
+      filename: options.filename || 'style.css',
+      code: Buffer.from(css),
+      minify: true,
+      sourceMap: false,
+      targets: {
+        chrome: 90 << 16,
+        firefox: 88 << 16,
+        safari: 14 << 16,
+        edge: 90 << 16
+      },
+      drafts: {
+        nesting: true
+      }
+    });
+    return code.toString();
+  } catch (error) {
+    logger.warn(`CSS minification failed: ${error.message}`);
+    // Fallback minification
+    return css
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/\s+/g, ' ')
+      .replace(/\s*([{}:;,])\s*/g, '$1')
+      .replace(/;}/g, '}')
+      .trim();
+  }
+}
+
+export function combineCSS(files) {
+  return files.map(({ filename, content }) => 
+    `/* ${filename} */\n${content}`
+  ).join('\n\n');
+}
+
+
+export { minifyCSS, minifyCSSSync, combineCSS, extractCSSImports, isCSSFile } from './processor.js';
+export { buildAllCSS } from '../build/processors/css-builder.js';
+export { buildCSS, copyCSS } from '../build/css-builder.js';

package/src/css/processor.js

@@ -0,0 +1,127 @@
+// bertui/src/css/processor.js - PURE CSS PROCESSING
+import { transform } from 'lightningcss';
+import logger from '../logger/logger.js';
+
+/**
+ * Minify CSS using Lightning CSS with fallback
+ */
+export async function minifyCSS(css, options = {}) {
+  const {
+    filename = 'style.css',
+    minify = true,
+    sourceMap = false,
+    targets = {
+      chrome: 90 << 16,
+      firefox: 88 << 16,
+      safari: 14 << 16,
+      edge: 90 << 16
+    }
+  } = options;
+
+  // Empty CSS
+  if (!css || css.trim() === '') {
+    return '/* Empty CSS */';
+  }
+
+  try {
+    const { code } = transform({
+      filename,
+      code: Buffer.from(css),
+      minify,
+      sourceMap,
+      targets,
+      drafts: {
+        nesting: true
+      }
+    });
+    
+    return code.toString();
+  } catch (error) {
+    logger.warn(`Lightning CSS failed: ${error.message}, using fallback minifier`);
+    return fallbackMinifyCSS(css);
+  }
+}
+
+/**
+ * Synchronous version for build scripts
+ */
+export function minifyCSSSync(css, options = {}) {
+  const {
+    filename = 'style.css',
+    minify = true,
+    sourceMap = false
+  } = options;
+
+  if (!css || css.trim() === '') {
+    return '/* Empty CSS */';
+  }
+
+  try {
+    const { code } = transform({
+      filename,
+      code: Buffer.from(css),
+      minify,
+      sourceMap,
+      drafts: {
+        nesting: true
+      }
+    });
+    return code.toString();
+  } catch (error) {
+    return fallbackMinifyCSS(css);
+  }
+}
+
+/**
+ * Combine multiple CSS files into one
+ */
+export function combineCSS(files) {
+  if (!Array.isArray(files)) {
+    throw new Error('combineCSS expects an array of {filename, content}');
+  }
+
+  return files.map(({ filename, content }) => {
+    // Add file comment for debugging
+    const header = `/* ${filename} */\n`;
+    return header + content;
+  }).join('\n\n');
+}
+
+/**
+ * Fallback CSS minifier (simple but works)
+ */
+function fallbackMinifyCSS(css) {
+  return css
+    // Remove comments
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // Remove whitespace
+    .replace(/\s+/g, ' ')
+    // Remove space around { } : ; ,
+    .replace(/\s*([{}:;,])\s*/g, '$1')
+    // Remove last semicolon before }
+    .replace(/;}/g, '}')
+    // Remove leading/trailing space
+    .trim();
+}
+
+/**
+ * Extract CSS imports from JavaScript
+ */
+export function extractCSSImports(code) {
+  const imports = [];
+  const regex = /import\s+['"]([^'"]*\.css)['"];?/g;
+  let match;
+  
+  while ((match = regex.exec(code)) !== null) {
+    imports.push(match[1]);
+  }
+  
+  return imports;
+}
+
+/**
+ * Check if file is CSS
+ */
+export function isCSSFile(filename) {
+  return filename.toLowerCase().endsWith('.css');
+}

package/src/image-optimizer/index.js

@@ -0,0 +1,76 @@
+// 3. src/image-optimizer/index.js - USE OXIPNG BINARY
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { writeFile, readFile, unlink } from 'fs/promises';
+
+const execAsync = promisify(exec);
+
+export async function optimizeImage(buffer, options = {}) {
+  const { format = 'auto', quality = 3 } = options;
+  
+  // Detect format
+  const detectedFormat = format === 'auto' ? detectFormat(buffer) : format;
+  
+  // Only PNG supported for now
+  if (detectedFormat === 'png') {
+    return await optimizePNG(buffer, quality);
+  }
+  
+  // Fallback to copy
+  return fallbackOptimize(buffer, detectedFormat);
+}
+
+async function optimizePNG(buffer, level = 3) {
+  const original_size = buffer.byteLength;
+  
+  // Write temp file
+  const tmpPath = join(tmpdir(), `bertui-${Date.now()}.png`);
+  const outPath = join(tmpdir(), `bertui-${Date.now()}-opt.png`);
+  
+  try {
+    await writeFile(tmpPath, Buffer.from(buffer));
+    
+    // Run oxipng binary
+    await execAsync(`oxipng -o ${level} -s "${tmpPath}" -o "${outPath}"`);
+    
+    // Read optimized file
+    const optimized = await readFile(outPath);
+    const optimized_size = optimized.length;
+    const savings_percent = ((original_size - optimized_size) / original_size * 100).toFixed(1);
+    
+    return {
+      data: optimized.buffer,
+      original_size,
+      optimized_size,
+      format: 'png',
+      savings_percent: parseFloat(savings_percent)
+    };
+  } finally {
+    // Cleanup
+    await unlink(tmpPath).catch(() => {});
+    await unlink(outPath).catch(() => {});
+  }
+}
+
+function fallbackOptimize(buffer, format) {
+  return {
+    data: buffer,
+    original_size: buffer.byteLength,
+    optimized_size: buffer.byteLength,
+    format,
+    savings_percent: 0
+  };
+}
+
+function detectFormat(buffer) {
+  if (buffer.length >= 8) {
+    const pngSig = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
+    if (pngSig.every((b, i) => buffer[i] === b)) return 'png';
+  }
+  return 'unknown';
+}
+
+export const hasWasm = () => false;
+export const version = '1.1.7';

package/src/images/index.js

@@ -0,0 +1,102 @@
+// bertui/src/images/index.js
+// PURE image handling - NO WASM, NO SHARP, just copy (FALLBACK)
+
+import { join, extname } from 'path';
+import { cpSync, mkdirSync, existsSync, readdirSync } from 'fs';
+import logger from '../logger/logger.js';
+
+export const IMAGE_EXTENSIONS = [
+  '.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg', 
+  '.avif', '.ico', '.bmp', '.tiff', '.tif'
+];
+
+export function isImageFile(filename) {
+  const ext = extname(filename).toLowerCase();
+  return IMAGE_EXTENSIONS.includes(ext);
+}
+
+export function copyImagesSync(srcDir, destDir) {
+  let copied = 0;
+  let skipped = 0;
+
+  if (!existsSync(srcDir)) return { copied, skipped };
+
+  mkdirSync(destDir, { recursive: true });
+
+  function process(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 subDest = join(targetDir, entry.name);
+        mkdirSync(subDest, { recursive: true });
+        process(srcPath, subDest);
+      } else if (entry.isFile() && isImageFile(entry.name)) {
+        try {
+          cpSync(srcPath, destPath);
+          copied++;
+        } catch (error) {
+          logger.warn(`Failed to copy ${entry.name}: ${error.message}`);
+          skipped++;
+        }
+      } else {
+        skipped++;
+      }
+    }
+  }
+
+  process(srcDir, destDir);
+  return { copied, skipped };
+}
+
+export function getImageContentType(ext) {
+  const types = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon'
+  };
+  return types[ext.toLowerCase()] || 'application/octet-stream';
+}
+
+export function getImageFiles(dir, baseDir = dir) {
+  const images = [];
+  if (!existsSync(dir)) return images;
+
+  function scan(directory) {
+    const entries = readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(directory, entry.name);
+      const relativePath = fullPath.replace(baseDir, '').replace(/^[\/\\]/, '');
+      if (entry.isDirectory()) {
+        scan(fullPath);
+      } else if (entry.isFile() && isImageFile(entry.name)) {
+        images.push({ path: fullPath, relativePath, filename: entry.name });
+      }
+    }
+  }
+  scan(dir);
+  return images;
+}
+
+export function getTotalImageSize(images) {
+  return images.reduce((total, img) => total + img.size, 0);
+}
+
+export 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]}`;
+}
+
+// Legacy exports
+export { optimizeImages, copyImages } from '../build/image-optimizer.js';

package/src/images/processor.js

@@ -0,0 +1,169 @@
+// bertui/src/images/processor.js - PURE IMAGE PROCESSING
+import { join, extname } from 'path';
+import { cpSync, mkdirSync, existsSync, readdirSync, statSync } from 'fs';
+import logger from '../logger/logger.js';
+
+// All supported image formats
+export const IMAGE_EXTENSIONS = [
+  '.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg', 
+  '.avif', '.ico', '.bmp', '.tiff', '.tif'
+];
+
+/**
+ * Check if a file is an image based on extension
+ */
+export function isImageFile(filename) {
+  if (!filename) return false;
+  const ext = extname(filename).toLowerCase();
+  return IMAGE_EXTENSIONS.includes(ext);
+}
+
+/**
+ * Get image content type for HTTP headers
+ */
+export function getImageContentType(ext) {
+  const types = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.bmp': 'image/bmp',
+    '.tiff': 'image/tiff',
+    '.tif': 'image/tiff'
+  };
+  
+  return types[ext.toLowerCase()] || 'application/octet-stream';
+}
+
+/**
+ * Copy images synchronously from source to destination
+ */
+export function copyImagesSync(srcDir, destDir, options = {}) {
+  const {
+    verbose = false,
+    overwrite = true,
+    filter = null
+  } = options;
+
+  let copied = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  if (!existsSync(srcDir)) {
+    logger.warn(`Source directory not found: ${srcDir}`);
+    return { copied, skipped, failed };
+  }
+
+  // Create destination directory
+  mkdirSync(destDir, { recursive: true });
+
+  function copyDir(dir, targetDir) {
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const srcPath = join(dir, entry.name);
+        const destPath = join(targetDir, entry.name);
+
+        // Skip if filtered
+        if (filter && !filter(srcPath)) {
+          skipped++;
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          // Recursively copy subdirectories
+          const subDest = join(targetDir, entry.name);
+          mkdirSync(subDest, { recursive: true });
+          copyDir(srcPath, subDest);
+        } 
+        else if (entry.isFile() && isImageFile(entry.name)) {
+          try {
+            // Check if destination exists and we should overwrite
+            if (!overwrite && existsSync(destPath)) {
+              skipped++;
+              if (verbose) logger.debug(`Skipped existing: ${entry.name}`);
+              continue;
+            }
+
+            cpSync(srcPath, destPath);
+            copied++;
+            
+            if (verbose) {
+              const srcSize = statSync(srcPath).size;
+              logger.debug(`Copied: ${entry.name} (${(srcSize / 1024).toFixed(2)}KB)`);
+            }
+          } catch (error) {
+            failed++;
+            logger.warn(`Failed to copy ${entry.name}: ${error.message}`);
+          }
+        } else {
+          skipped++;
+        }
+      }
+    } catch (error) {
+      logger.error(`Error processing ${dir}: ${error.message}`);
+    }
+  }
+
+  copyDir(srcDir, destDir);
+
+  return { copied, skipped, failed };
+}
+
+/**
+ * Get all image files from a directory recursively
+ */
+export function getImageFiles(dir, baseDir = dir) {
+  const images = [];
+
+  if (!existsSync(dir)) {
+    return images;
+  }
+
+  function scan(directory) {
+    const entries = readdirSync(directory, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(directory, entry.name);
+      const relativePath = fullPath.replace(baseDir, '').replace(/^[\/\\]/, '');
+
+      if (entry.isDirectory()) {
+        scan(fullPath);
+      } else if (entry.isFile() && isImageFile(entry.name)) {
+        images.push({
+          path: fullPath,
+          relativePath,
+          filename: entry.name,
+          size: statSync(fullPath).size,
+          ext: extname(entry.name).toLowerCase()
+        });
+      }
+    }
+  }
+
+  scan(dir);
+  return images;
+}
+
+/**
+ * Calculate total size of images
+ */
+export function getTotalImageSize(images) {
+  return images.reduce((total, img) => total + img.size, 0);
+}
+
+/**
+ * Format bytes to human readable
+ */
+export 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/router/index.js

@@ -0,0 +1,3 @@
+// bertui/src/router/index.js
+export { Router, Link, useRouter } from './Router.jsx';
+export { SSRRouter } from './SSRRouter.jsx';