build.cjs

#!/usr/bin/env node
/**
 * Build script for EZCONTACTFORM Widget
 * 
 * Updates version in widget.js and generates versioned distribution files.
 * 
 * Usage:
 *   node build.js              # Build from package.json version
 *   node build.js --tag        # Build from Git tag
 *   node build.js --version 1.4.0  # Build with specific version
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

// Minification libraries (loaded lazily)
let Terser = null;
let CleanCSS = null;

/**
 * Load minification libraries
 */
function loadMinifiers() {
  try {
    Terser = require('terser');
    CleanCSS = require('clean-css');
    return true;
  } catch (err) {
    console.warn('⚠️  Minification libraries not installed. Run: npm install');
    console.warn('   Skipping minification...');
    return false;
  }
}

/**
 * Minify JavaScript file
 */
async function minifyJS(inputPath, outputPath) {
  if (!Terser) return false;
  
  const code = fs.readFileSync(inputPath, 'utf8');
  const result = await Terser.minify(code, {
    compress: {
      drop_console: false,  // Keep console.log for debugging
      drop_debugger: true,
      passes: 2
    },
    mangle: {
      reserved: ['EZForm']  // Don't mangle the global EZForm object
    },
    format: {
      comments: /^!/  // Keep comments starting with !
    }
  });
  
  if (result.error) {
    throw result.error;
  }
  
  // Add banner comment
  const banner = `/*! EZForm Widget - https://ezcontactform.com */\n`;
  fs.writeFileSync(outputPath, banner + result.code, 'utf8');
  return true;
}

/**
 * Minify CSS file
 */
function minifyCSS(inputPath, outputPath) {
  if (!CleanCSS) return false;
  
  const css = fs.readFileSync(inputPath, 'utf8');
  const minifier = new CleanCSS({
    level: 2,
    format: false
  });
  
  const result = minifier.minify(css);
  
  if (result.errors && result.errors.length > 0) {
    throw new Error(result.errors.join(', '));
  }
  
  // Add banner comment
  const banner = `/*! EZForm Widget Styles - https://ezcontactform.com */\n`;
  fs.writeFileSync(outputPath, banner + result.styles, 'utf8');
  return true;
}

// ANSI color codes for terminal output
const colors = {
  reset: '\x1b[0m',
  bright: '\x1b[1m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  red: '\x1b[31m',
  blue: '\x1b[34m',
};

function log(message, color = 'reset') {
  console.log(`${colors[color]}${message}${colors.reset}`);
}

function error(message) {
  log(`❌ ${message}`, 'red');
  process.exit(1);
}

function success(message) {
  log(`✅ ${message}`, 'green');
}

function info(message) {
  log(`ℹ️  ${message}`, 'blue');
}

/**
 * Get version from command line args, Git tag, or package.json
 */
function getVersion() {
  const args = process.argv.slice(2);
  
  // Check for --version flag
  if (args.includes('--version')) {
    const idx = args.indexOf('--version');
    const version = args[idx + 1];
    if (!version) {
      error('--version flag requires a version number (e.g., --version 1.4.0)');
    }
    if (!isValidSemver(version)) {
      error(`Invalid version format: ${version}. Use semantic versioning (e.g., 1.4.0)`);
    }
    return version;
  }
  
  // Check for --tag flag
  if (args.includes('--tag')) {
    try {
      const tag = execSync('git describe --tags --exact-match HEAD 2>/dev/null', { 
        encoding: 'utf8',
        stdio: ['pipe', 'pipe', 'ignore']
      }).trim();
      const version = tag.replace(/^v/, ''); // Remove 'v' prefix
      if (!isValidSemver(version)) {
        error(`Git tag is not valid semver: ${tag}`);
      }
      info(`Using version from Git tag: ${tag}`);
      return version;
    } catch (err) {
      error('No Git tag found for current commit. Use --version or create a tag first.');
    }
  }
  
  // Default: read from package.json
  try {
    const pkgPath = path.join(process.cwd(), 'package.json');
    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
    const version = pkg.version;
    if (!version) {
      error('No version found in package.json');
    }
    if (!isValidSemver(version)) {
      error(`Invalid version in package.json: ${version}`);
    }
    info(`Using version from package.json: ${version}`);
    return version;
  } catch (err) {
    error(`Failed to read package.json: ${err.message}`);
  }
}

/**
 * Validate semantic version format
 */
function isValidSemver(version) {
  const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9-]+)?(\+[a-zA-Z0-9-]+)?$/;
  return semverRegex.test(version);
}

/**
 * Update version in widget.js file
 */
function updateVersion(filePath, version) {
  if (!fs.existsSync(filePath)) {
    error(`File not found: ${filePath}`);
  }
  
  let content = fs.readFileSync(filePath, 'utf8');
  const originalContent = content;
  
  // Check if version patterns exist before replacing
  const versionPattern1 = /Version:\s*\d+\.\d+\.\d+(-[a-zA-Z0-9-]+)?(\+[a-zA-Z0-9-]+)?/g;
  const versionPattern2 = /version:\s*['"]\d+\.\d+\.\d+(-[a-zA-Z0-9-]+)?(\+[a-zA-Z0-9-]+)?['"]/g;
  
  const hasVersion1 = versionPattern1.test(content);
  const hasVersion2 = versionPattern2.test(content);
  
  if (!hasVersion1 && !hasVersion2) {
    error(`No version patterns found in ${filePath}. Make sure the file contains 'Version: X.Y.Z' or version: 'X.Y.Z'`);
  }
  
  // Reset regex lastIndex for replace operations
  versionPattern1.lastIndex = 0;
  versionPattern2.lastIndex = 0;
  
  // Update header comment: Version: X.Y.Z
  content = content.replace(versionPattern1, `Version: ${version}`);
  
  // Update code constant: version: 'X.Y.Z'
  content = content.replace(versionPattern2, `version: '${version}'`);
  
  fs.writeFileSync(filePath, content, 'utf8');
  success(`Updated version in ${path.basename(filePath)}`);
}

/**
 * Copy file to destination
 */
function copyFile(src, dest) {
  const destDir = path.dirname(dest);
  if (!fs.existsSync(destDir)) {
    fs.mkdirSync(destDir, { recursive: true });
  }
  fs.copyFileSync(src, dest);
}

/**
 * Main build function
 */
async function build() {
  const version = getVersion();
  log(`\n${colors.bright}Building widget v${version}...${colors.reset}\n`);
  
  const srcDir = path.join(process.cwd(), 'src');
  const distDir = path.join(process.cwd(), 'dist');
  
  // Ensure src directory exists
  if (!fs.existsSync(srcDir)) {
    error(`Source directory not found: ${srcDir}`);
  }
  
  const widgetJsPath = path.join(srcDir, 'widget.js');
  const widgetCssPath = path.join(srcDir, 'widget.css');
  const ezformJsPath = path.join(srcDir, 'ezform.js');
  
  // Check source files exist
  if (!fs.existsSync(widgetJsPath)) {
    error(`Widget JS file not found: ${widgetJsPath}`);
  }
  if (!fs.existsSync(widgetCssPath)) {
    error(`Widget CSS file not found: ${widgetCssPath}`);
  }
  if (!fs.existsSync(ezformJsPath)) {
    error(`EZForm JS file not found: ${ezformJsPath}`);
  }
  
  // Load minification libraries
  const canMinify = loadMinifiers();
  
  // Create dist directory
  if (!fs.existsSync(distDir)) {
    fs.mkdirSync(distDir, { recursive: true });
  }
  
  // --- Build widget.js ---
  const tempWidgetJs = path.join(distDir, '.widget.js.tmp');
  copyFile(widgetJsPath, tempWidgetJs);
  updateVersion(tempWidgetJs, version);
  
  const versionedJs = path.join(distDir, `widget-${version}.js`);
  const versionedCss = path.join(distDir, `widget-${version}.css`);
  const versionedJsMin = path.join(distDir, `widget-${version}.min.js`);
  const versionedCssMin = path.join(distDir, `widget-${version}.min.css`);
  
  copyFile(tempWidgetJs, versionedJs);
  copyFile(widgetCssPath, versionedCss);
  
  const latestJs = path.join(distDir, 'widget.js');
  const latestCss = path.join(distDir, 'widget.css');
  const latestJsMin = path.join(distDir, 'widget.min.js');
  const latestCssMin = path.join(distDir, 'widget.min.css');
  
  copyFile(versionedJs, latestJs);
  copyFile(versionedCss, latestCss);
  
  // Minify widget files
  if (canMinify) {
    await minifyJS(versionedJs, versionedJsMin);
    minifyCSS(versionedCss, versionedCssMin);
    copyFile(versionedJsMin, latestJsMin);
    copyFile(versionedCssMin, latestCssMin);
    success(`Minified widget.js and widget.css`);
  }
  
  fs.unlinkSync(tempWidgetJs);
  
  // --- Build ezform.js ---
  const tempEzformJs = path.join(distDir, '.ezform.js.tmp');
  copyFile(ezformJsPath, tempEzformJs);
  
  // ezform.js may not have version patterns, so we add one if needed
  let ezformContent = fs.readFileSync(tempEzformJs, 'utf8');
  
  // Check if version pattern exists, if not add it to header
  const hasVersionHeader = /Version:\s*\d+\.\d+\.\d+/.test(ezformContent);
  if (!hasVersionHeader) {
    // Add version to the header comment
    ezformContent = ezformContent.replace(
      /\/\*\*\n \* EZForm Helper Script/,
      `/**\n * EZForm Helper Script\n * Version: ${version}`
    );
    fs.writeFileSync(tempEzformJs, ezformContent, 'utf8');
    success(`Added version to ezform.js header`);
  } else {
    // Update existing version
    ezformContent = ezformContent.replace(
      /Version:\s*\d+\.\d+\.\d+(-[a-zA-Z0-9-]+)?(\+[a-zA-Z0-9-]+)?/g,
      `Version: ${version}`
    );
    fs.writeFileSync(tempEzformJs, ezformContent, 'utf8');
    success(`Updated version in ezform.js`);
  }
  
  const versionedEzformJs = path.join(distDir, `ezform-${version}.js`);
  const versionedEzformJsMin = path.join(distDir, `ezform-${version}.min.js`);
  const latestEzformJs = path.join(distDir, 'ezform.js');
  const latestEzformJsMin = path.join(distDir, 'ezform.min.js');
  
  copyFile(tempEzformJs, versionedEzformJs);
  copyFile(versionedEzformJs, latestEzformJs);
  
  // Minify ezform files
  if (canMinify) {
    await minifyJS(versionedEzformJs, versionedEzformJsMin);
    copyFile(versionedEzformJsMin, latestEzformJsMin);
    success(`Minified ezform.js`);
  }
  
  fs.unlinkSync(tempEzformJs);
  
  // Output summary
  log(`\n${colors.bright}Build Summary:${colors.reset}`);
  log(`  Version: ${colors.green}${version}${colors.reset}`);
  log(`  Files generated:`);
  log(`    ${colors.blue}dist/widget-${version}.js${colors.reset}`);
  log(`    ${colors.blue}dist/widget-${version}.css${colors.reset}`);
  if (canMinify) {
    log(`    ${colors.blue}dist/widget-${version}.min.js${colors.reset} (minified)`);
    log(`    ${colors.blue}dist/widget-${version}.min.css${colors.reset} (minified)`);
  }
  log(`    ${colors.blue}dist/widget.js${colors.reset} (latest)`);
  log(`    ${colors.blue}dist/widget.css${colors.reset} (latest)`);
  if (canMinify) {
    log(`    ${colors.blue}dist/widget.min.js${colors.reset} (latest, minified)`);
    log(`    ${colors.blue}dist/widget.min.css${colors.reset} (latest, minified)`);
  }
  log(`    ${colors.blue}dist/ezform-${version}.js${colors.reset}`);
  if (canMinify) {
    log(`    ${colors.blue}dist/ezform-${version}.min.js${colors.reset} (minified)`);
  }
  log(`    ${colors.blue}dist/ezform.js${colors.reset} (latest)`);
  if (canMinify) {
    log(`    ${colors.blue}dist/ezform.min.js${colors.reset} (latest, minified)`);
  }
  
  // Get file sizes
  const jsSize = (fs.statSync(versionedJs).size / 1024).toFixed(2);
  const cssSize = (fs.statSync(versionedCss).size / 1024).toFixed(2);
  const ezformSize = (fs.statSync(versionedEzformJs).size / 1024).toFixed(2);
  log(`\n  File sizes:`);
  log(`    widget-${version}.js: ${jsSize} KB`);
  log(`    widget-${version}.css: ${cssSize} KB`);
  log(`    ezform-${version}.js: ${ezformSize} KB`);
  
  if (canMinify) {
    const jsMinSize = (fs.statSync(versionedJsMin).size / 1024).toFixed(2);
    const cssMinSize = (fs.statSync(versionedCssMin).size / 1024).toFixed(2);
    const ezformMinSize = (fs.statSync(versionedEzformJsMin).size / 1024).toFixed(2);
    log(`\n  Minified sizes:`);
    log(`    widget-${version}.min.js: ${jsMinSize} KB (${((1 - jsMinSize/jsSize) * 100).toFixed(0)}% smaller)`);
    log(`    widget-${version}.min.css: ${cssMinSize} KB (${((1 - cssMinSize/cssSize) * 100).toFixed(0)}% smaller)`);
    log(`    ezform-${version}.min.js: ${ezformMinSize} KB (${((1 - ezformMinSize/ezformSize) * 100).toFixed(0)}% smaller)`);
  }
  
  success(`\nBuild completed successfully!`);
  
  return {
    version,
    files: {
      versionedJs,
      versionedCss,
      versionedJsMin: canMinify ? versionedJsMin : null,
      versionedCssMin: canMinify ? versionedCssMin : null,
      latestJs,
      latestCss,
      latestJsMin: canMinify ? latestJsMin : null,
      latestCssMin: canMinify ? latestCssMin : null,
      versionedEzformJs,
      versionedEzformJsMin: canMinify ? versionedEzformJsMin : null,
      latestEzformJs,
      latestEzformJsMin: canMinify ? latestEzformJsMin : null
    }
  };
}

// Run build if executed directly
if (require.main === module) {
  build().catch(err => {
    error(err.message);
  });
}

module.exports = { build, getVersion };