easybuild-nox 1.0.0

package/src/targets/electron.js

@@ -0,0 +1,157 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+
+class ElectronBuilder {
+  constructor(projectInfo, config) {
+    this.projectInfo = projectInfo;
+    this.config = config;
+    this.outDir = config.outDir || 'release';
+  }
+
+  async build(options) {
+    logger.section('Building Electron Application');
+
+    // Ensure electron-builder config exists
+    await this.ensureConfig();
+
+    // Build for specified platforms
+    const platforms = this.getPlatforms(options.platform);
+    const arch = this.getArch(options.arch);
+
+    for (const platform of platforms) {
+      await this.buildForPlatform(platform, arch, options);
+    }
+  }
+
+  async ensureConfig() {
+    const configPath = path.join(process.cwd(), 'electron-builder.yml');
+    const configJsonPath = path.join(process.cwd(), 'electron-builder.json');
+
+    if (!(await fs.pathExists(configPath)) && !(await fs.pathExists(configJsonPath))) {
+      logger.info('Generating electron-builder configuration...');
+
+      const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+      const electronConfig = this.config.electron || {};
+
+      const builderConfig = {
+        appId: `com.${pkg.name || 'app'}.electron`,
+        productName: pkg.name || 'Electron App',
+        directories: {
+          output: electronConfig.output || 'release',
+        },
+        files: [
+          'electron/**/*',
+          'dist/**/*',
+          'package.json',
+        ],
+        mac: {
+          category: 'public.app-category.developer-tools',
+          icon: electronConfig.icon || null,
+          target: [
+            { target: 'dmg', arch: ['x64', 'arm64'] },
+            { target: 'zip', arch: ['x64', 'arm64'] },
+          ],
+        },
+        win: {
+          icon: electronConfig.icon || null,
+          target: [
+            { target: 'nsis', arch: ['x64'] },
+            { target: 'portable', arch: ['x64'] },
+          ],
+        },
+        linux: {
+          icon: electronConfig.icon || null,
+          target: [
+            { target: 'AppImage', arch: ['x64'] },
+            { target: 'deb', arch: ['x64'] },
+            { target: 'rpm', arch: ['x64'] },
+          ],
+          category: 'Development',
+        },
+        nsis: {
+          oneClick: false,
+          allowToChangeInstallationDirectory: true,
+        },
+      };
+
+      // Try to use js-yaml for YAML output
+      try {
+        const yaml = require('js-yaml');
+        await fs.writeFile(configPath, yaml.dump(builderConfig));
+      } catch {
+        // Fallback to JSON
+        await fs.writeJson(configJsonPath, builderConfig, { spaces: 2 });
+      }
+
+      logger.success('electron-builder configuration generated');
+    }
+  }
+
+  getPlatforms(platform) {
+    if (platform === 'all' || platform === 'current') {
+      if (platform === 'current') {
+        // Build for current platform only
+        switch (process.platform) {
+          case 'win32': return ['win'];
+          case 'darwin': return ['mac'];
+          default: return ['linux'];
+        }
+      }
+      return ['win', 'mac', 'linux'];
+    }
+    return [platform];
+  }
+
+  getArch(arch) {
+    if (arch === 'all') return ['x64', 'arm64'];
+    if (arch === 'current') return [process.arch === 'arm64' ? 'arm64' : 'x64'];
+    return [arch];
+  }
+
+  async buildForPlatform(platform, archList, options) {
+    logger.info(`Building for ${platform} (${archList.join(', ')})...`);
+
+    const args = ['electron-builder'];
+
+    // Platform
+    switch (platform) {
+      case 'win':
+        args.push('--win');
+        break;
+      case 'mac':
+        args.push('--mac');
+        break;
+      case 'linux':
+        args.push('--linux');
+        break;
+    }
+
+    // Architecture
+    for (const a of archList) {
+      args.push(`--${a}`);
+    }
+
+    // Other options
+    if (options.minify === false) args.push('--config', 'minify=false');
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success(`Build completed for ${platform}`);
+          resolve();
+        } else {
+          reject(new Error(`Build failed for ${platform}`));
+        }
+      });
+    });
+  }
+}
+
+module.exports = ElectronBuilder;

package/src/targets/frontend.js

@@ -0,0 +1,391 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+
+class FrontendBuilder {
+  constructor(projectInfo, config) {
+    this.projectInfo = projectInfo;
+    this.config = config;
+    this.outDir = config.outDir || 'dist';
+  }
+
+  async build(options) {
+    logger.section('Building Frontend Application');
+
+    const framework = this.projectInfo.framework?.name;
+
+    switch (framework) {
+      // Vite-based
+      case 'react':
+      case 'vue':
+      case 'svelte':
+      case 'solid':
+      case 'preact':
+      case 'lit':
+      case 'alpine':
+      case 'htmx':
+        await this.buildWithVite(options);
+        break;
+
+      // Angular
+      case 'angular':
+        await this.buildWithAngular(options);
+        break;
+
+      // Full-stack frameworks
+      case 'nextjs':
+        await this.buildNextjs(options);
+        break;
+      case 'nuxt':
+        await this.buildNuxt(options);
+        break;
+      case 'remix':
+        await this.buildRemix(options);
+        break;
+      case 'gatsby':
+        await this.buildGatsby(options);
+        break;
+      case 'astro':
+        await this.buildAstro(options);
+        break;
+      case 'sveltekit':
+        await this.buildSvelteKit(options);
+        break;
+      case 'solidstart':
+        await this.buildSolidStart(options);
+        break;
+      case 'qwik':
+        await this.buildQwik(options);
+        break;
+      case 'analog':
+        await this.buildAnalog(options);
+        break;
+      case 'fresh':
+        await this.buildFresh(options);
+        break;
+      case 'tanstack':
+        await this.buildTanStack(options);
+        break;
+      case 'waku':
+        await this.buildWaku(options);
+        break;
+
+      default:
+        await this.buildWithVite(options);
+    }
+  }
+
+  async buildWithVite(options) {
+    logger.info('Building with Vite...');
+
+    const args = ['vite', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Vite');
+          resolve();
+        } else {
+          reject(new Error('Vite build failed'));
+        }
+      });
+    });
+  }
+
+  async buildWithAngular(options) {
+    logger.info('Building with Angular CLI...');
+
+    const args = ['ng', 'build', '--configuration', 'production'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Angular');
+          resolve();
+        } else {
+          reject(new Error('Angular build failed'));
+        }
+      });
+    });
+  }
+
+  async buildNextjs(options) {
+    logger.info('Building Next.js application...');
+
+    const args = ['next', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Next.js');
+          resolve();
+        } else {
+          reject(new Error('Next.js build failed'));
+        }
+      });
+    });
+  }
+
+  async buildNuxt(options) {
+    logger.info('Building Nuxt application...');
+
+    const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+    const hasNuxt3 = pkg.devDependencies?.nuxt?.startsWith('3') || pkg.dependencies?.nuxt?.startsWith('3');
+
+    const args = hasNuxt3 ? ['nuxt', 'build'] : ['nuxt', 'generate'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Nuxt');
+          resolve();
+        } else {
+          reject(new Error('Nuxt build failed'));
+        }
+      });
+    });
+  }
+
+  async buildRemix(options) {
+    logger.info('Building Remix application...');
+
+    const args = ['remix', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Remix');
+          resolve();
+        } else {
+          reject(new Error('Remix build failed'));
+        }
+      });
+    });
+  }
+
+  async buildGatsby(options) {
+    logger.info('Building Gatsby application...');
+
+    const args = ['gatsby', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Gatsby');
+          resolve();
+        } else {
+          reject(new Error('Gatsby build failed'));
+        }
+      });
+    });
+  }
+
+  async buildAstro(options) {
+    logger.info('Building Astro application...');
+
+    const args = ['astro', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Astro');
+          resolve();
+        } else {
+          reject(new Error('Astro build failed'));
+        }
+      });
+    });
+  }
+
+  async buildSvelteKit(options) {
+    logger.info('Building SvelteKit application...');
+
+    const args = ['svelte-kit', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with SvelteKit');
+          resolve();
+        } else {
+          reject(new Error('SvelteKit build failed'));
+        }
+      });
+    });
+  }
+
+  async buildSolidStart(options) {
+    logger.info('Building SolidStart application...');
+
+    const args = ['solid-start', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with SolidStart');
+          resolve();
+        } else {
+          reject(new Error('SolidStart build failed'));
+        }
+      });
+    });
+  }
+
+  async buildQwik(options) {
+    logger.info('Building Qwik application...');
+
+    const args = ['qwik', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Qwik');
+          resolve();
+        } else {
+          reject(new Error('Qwik build failed'));
+        }
+      });
+    });
+  }
+
+  async buildAnalog(options) {
+    logger.info('Building Analog application...');
+
+    const args = ['ng', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Analog');
+          resolve();
+        } else {
+          reject(new Error('Analog build failed'));
+        }
+      });
+    });
+  }
+
+  async buildFresh(options) {
+    logger.info('Building Fresh application...');
+
+    const args = ['deno', 'task', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Fresh');
+          resolve();
+        } else {
+          reject(new Error('Fresh build failed'));
+        }
+      });
+    });
+  }
+
+  async buildTanStack(options) {
+    logger.info('Building TanStack application...');
+
+    const args = ['tanstack-start', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with TanStack');
+          resolve();
+        } else {
+          reject(new Error('TanStack build failed'));
+        }
+      });
+    });
+  }
+
+  async buildWaku(options) {
+    logger.info('Building Waku application...');
+
+    const args = ['waku', 'build'];
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('Build completed with Waku');
+          resolve();
+        } else {
+          reject(new Error('Waku build failed'));
+        }
+      });
+    });
+  }
+}
+
+module.exports = FrontendBuilder;

package/src/targets/library.js

@@ -0,0 +1,164 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+
+class LibraryBuilder {
+  constructor(projectInfo, config) {
+    this.projectInfo = projectInfo;
+    this.config = config;
+    this.outDir = config.outDir || 'dist';
+  }
+
+  async build(options) {
+    logger.section('Building Library');
+
+    // Check if TypeScript project
+    if (this.projectInfo.isTypeScript) {
+      await this.buildTypeScript(options);
+    } else {
+      await this.buildJavaScript(options);
+    }
+  }
+
+  async buildTypeScript(options) {
+    logger.info('Building TypeScript library...');
+
+    // Check for tsconfig.json
+    const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+    if (!(await fs.pathExists(tsconfigPath))) {
+      logger.info('Generating tsconfig.json...');
+      await this.generateTsConfig();
+    }
+
+    const args = ['tsc'];
+
+    if (options.sourcemap) args.push('--sourceMap');
+    if (options.watch) args.push('--watch');
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          logger.success('TypeScript build completed');
+          resolve();
+        } else {
+          reject(new Error('TypeScript build failed'));
+        }
+      });
+    });
+  }
+
+  async buildJavaScript(options) {
+    logger.info('Building JavaScript library...');
+
+    const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+    const entryPoint = this.config.entry || pkg.main || 'src/index.js';
+
+    // Use esbuild for JavaScript
+    const args = [
+      'esbuild',
+      entryPoint,
+      '--bundle',
+      '--platform=node',
+      '--target=node18',
+      `--outdir=${options.outDir || this.outDir}`,
+    ];
+
+    if (options.minify) args.push('--minify');
+    if (options.sourcemap) args.push('--sourcemap');
+
+    // Generate multiple formats
+    await this.buildFormat(entryPoint, 'cjs', options);
+    await this.buildFormat(entryPoint, 'esm', options);
+
+    // Generate package.json for exports
+    await this.generateExports(pkg);
+
+    logger.success('JavaScript build completed');
+  }
+
+  async buildFormat(entryPoint, format, options) {
+    const outDir = path.join(options.outDir || this.outDir, format);
+
+    const args = [
+      'esbuild',
+      entryPoint,
+      '--bundle',
+      '--platform=node',
+      '--target=node18',
+      `--format=${format}`,
+      `--outdir=${outDir}`,
+    ];
+
+    if (options.minify) args.push('--minify');
+    if (options.sourcemap) args.push('--sourcemap');
+
+    const child = spawn('npx', args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`${format} build failed`));
+        }
+      });
+    });
+  }
+
+  async generateTsConfig() {
+    const tsconfig = {
+      compilerOptions: {
+        target: 'ES2020',
+        module: 'commonjs',
+        lib: ['ES2020'],
+        declaration: true,
+        strict: true,
+        noImplicitAny: true,
+        strictNullChecks: true,
+        noImplicitThis: true,
+        alwaysStrict: true,
+        outDir: './dist',
+        rootDir: './src',
+      },
+      include: ['src/**/*'],
+      exclude: ['node_modules', 'dist'],
+    };
+
+    await fs.writeJson(path.join(process.cwd(), 'tsconfig.json'), tsconfig, { spaces: 2 });
+    logger.success('tsconfig.json generated');
+  }
+
+  async generateExports(pkg) {
+    const distPath = path.join(process.cwd(), 'dist');
+
+    // Update package.json with exports
+    const updatedPkg = {
+      ...pkg,
+      main: 'dist/cjs/index.js',
+      module: 'dist/esm/index.js',
+      types: 'dist/types/index.d.ts',
+      exports: {
+        '.': {
+          import: './dist/esm/index.js',
+          require: './dist/cjs/index.js',
+          types: './dist/types/index.d.ts',
+        },
+      },
+      files: ['dist'],
+    };
+
+    await fs.writeJson(path.join(process.cwd(), 'package.json'), updatedPkg, { spaces: 2 });
+    logger.success('package.json exports updated');
+  }
+}
+
+module.exports = LibraryBuilder;