frontend-hamroun 1.2.79 → 1.2.82

package/templates/go-wasm-app/README.md

@@ -1,38 +0,0 @@
-# Frontend Hamroun - Go WebAssembly Template with SSR
-
-This template demonstrates integration between Frontend Hamroun, Go WebAssembly, and Server-Side Rendering for high-performance web applications.
-
-## Features
-
-- 🔄 Go + WebAssembly integration
-- 🌐 Server-Side Rendering with client hydration
-- ⚡ High-performance computation in both browser and server
-- 🚀 Same Go code runs in both environments
-- 🔍 SEO-friendly with pre-rendered HTML
-
-## Prerequisites
-
-- [Node.js](https://nodejs.org/) (v14+)
-- [Go](https://golang.org/dl/) (v1.16+)
-
-## Getting Started
-
-1. Install dependencies:
-   ```
-   npm install
-   ```
-
-2. Start the development server:
-   ```
-   npm run dev
-   ```
-
-3. Open your browser and navigate to `http://localhost:3000`
-
-The development server includes:
-- Automatic WASM compilation from Go source
-- Server-side rendering with Express
-- Hot reloading of server code with Node's `--watch` flag
-- Client-side hydration for interactivity
-
-## Project Structure

package/templates/go-wasm-app/babel.config.js

@@ -1,21 +0,0 @@
-const config = {
-  presets: [
-    ['@babel/preset-env', {
-      targets: {
-        node: 'current'
-      },
-      // Enable dynamic imports for both ESM and CommonJS
-      modules: false
-    }]
-  ],
-  plugins: [
-    ['@babel/plugin-transform-react-jsx', {
-      pragma: 'createElement',
-      pragmaFrag: 'Fragment'
-    }]
-  ]
-};
-
-// Support both ESM and CommonJS
-export default config;
-module.exports = config;

package/templates/go-wasm-app/build-client.js

@@ -1,49 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-// Get __dirname equivalent in ESM
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Output directory
-const outputDir = path.join(__dirname, 'dist');
-
-// Ensure output directory exists
-fs.ensureDirSync(outputDir);
-
-// Copy necessary files for production
-console.log('Copying files for production...');
-
-// Copy HTML template
-fs.copySync(path.join(__dirname, 'public', 'index.html'), path.join(outputDir, 'index.html'));
-
-// Copy WASM files
-const wasmDir = path.join(__dirname, 'public', 'wasm');
-const distWasmDir = path.join(outputDir, 'wasm');
-fs.ensureDirSync(distWasmDir);
-
-if (fs.existsSync(wasmDir)) {
-  fs.copySync(wasmDir, distWasmDir);
-  console.log('Copied WASM files to:', distWasmDir);
-} else {
-  console.warn('WASM directory not found:', wasmDir);
-}
-
-// Copy client.js for hydration
-const srcDir = path.join(__dirname, 'src');
-const distSrcDir = path.join(outputDir, 'src');
-fs.ensureDirSync(distSrcDir);
-fs.copySync(path.join(srcDir, 'client.js'), path.join(distSrcDir, 'client.js'));
-
-// Copy any other static assets
-const publicDir = path.join(__dirname, 'public');
-fs.readdirSync(publicDir).forEach(file => {
-  if (file !== 'index.html' && file !== 'wasm') {
-    const srcPath = path.join(publicDir, file);
-    const destPath = path.join(outputDir, file);
-    fs.copySync(srcPath, destPath);
-  }
-});
-
-console.log('Build completed successfully.');

package/templates/go-wasm-app/build-wasm.js

@@ -1,237 +0,0 @@
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, resolve, join } from 'path';
-import fs from 'fs';
-import os from 'os';
-
-// Get __dirname equivalent in ESM
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Check if running on Windows
-const isWindows = os.platform() === 'win32';
-
-// Check if Go is installed
-function checkGoInstallation() {
-  try {
-    const output = execSync('go version', { encoding: 'utf8' });
-    console.log(`✓ Found Go: ${output.trim()}`);
-    return true;
-  } catch (error) {
-    console.error('✗ Go is not installed or not in PATH');
-    console.error('Please install Go from https://golang.org/dl/');
-    return false;
-  }
-}
-
-// Ensure directory exists
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-    console.log(`Created directory: ${dir}`);
-  }
-}
-
-// Build Go WASM modules
-async function buildWasmModules() {
-  // Check if Go is installed
-  if (!checkGoInstallation()) {
-    process.exit(1);
-  }
-
-  // Directory containing Go source files
-  const goSourceDir = resolve(__dirname, 'src', 'wasm');
-  
-  // Output directory for WASM files
-  const wasmOutputDir = resolve(__dirname, 'public', 'wasm');
-  
-  // Create directories if they don't exist
-  ensureDir(goSourceDir);
-  ensureDir(wasmOutputDir);
-  
-  // Get the Go root directory
-  const goRoot = execSync('go env GOROOT', { encoding: 'utf8' }).trim();
-  
-  // Copy the wasm_exec.js files to the output directory (for both browser and Node.js)
-  const wasmExecJsPath = join(goRoot, 'misc', 'wasm', 'wasm_exec.js');
-  const wasmExecJsDest = join(wasmOutputDir, 'wasm_exec.js');
-  
-  const wasmExecNodeJsPath = join(goRoot, 'misc', 'wasm', 'wasm_exec_node.js');
-  const wasmExecNodeJsDest = join(wasmOutputDir, 'wasm_exec_node.js');
-  
-  console.log(`Copying ${wasmExecJsPath} to ${wasmExecJsDest}`);
-  fs.copyFileSync(wasmExecJsPath, wasmExecJsDest);
-  
-  console.log(`Copying ${wasmExecNodeJsPath} to ${wasmExecNodeJsDest}`);
-  fs.copyFileSync(wasmExecNodeJsPath, wasmExecNodeJsDest);
-  
-  // Build all Go files in the WASM directory
-  const goFiles = fs.readdirSync(goSourceDir).filter(file => file.endsWith('.go'));
-  
-  if (goFiles.length === 0) {
-    console.log('No Go files found in src/wasm');
-    
-    // Create an example Go file
-    const exampleGoFile = join(goSourceDir, 'example.go');
-    const exampleGoContent = `//go:build js && wasm
-// +build js,wasm
-
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"syscall/js"
-)
-
-// Example Go function to be called from JavaScript
-func add(this js.Value, args []js.Value) interface{} {
-	if len(args) != 2 {
-		return js.ValueOf("Error: Expected two arguments")
-	}
-	
-	a := args[0].Int()
-	b := args[1].Int()
-	return js.ValueOf(a + b)
-}
-
-// Process complex data in Go
-func processData(this js.Value, args []js.Value) interface{} {
-	if len(args) == 0 {
-		return js.ValueOf("Error: Expected at least one argument")
-	}
-
-	// Get input data
-	data := args[0]
-	if data.Type() != js.TypeObject {
-		return js.ValueOf("Error: Expected JSON object")
-	}
-
-	// Convert JS object to Go map
-	jsonStr := js.Global().Get("JSON").Call("stringify", data).String()
-	var inputMap map[string]interface{}
-	if err := json.Unmarshal([]byte(jsonStr), &inputMap); err != nil {
-		return js.ValueOf(fmt.Sprintf("Error parsing JSON: %s", err.Error()))
-	}
-
-	// Add new fields
-	inputMap["processed"] = true
-	inputMap["processor"] = "Go WASM"
-
-	// Add some computed fields
-	if values, ok := inputMap["values"].([]interface{}); ok {
-		sum := 0.0
-		for _, v := range values {
-			if num, ok := v.(float64); ok {
-				sum += num
-			}
-		}
-		inputMap["sum"] = sum
-	}
-
-	// Convert back to JS
-	resultJSON, err := json.Marshal(inputMap)
-	if err != nil {
-		return js.ValueOf(fmt.Sprintf("Error generating JSON: %s", err.Error()))
-	}
-
-	return js.ValueOf(string(resultJSON))
-}
-
-func main() {
-	fmt.Println("Go WASM Module initialized")
-	
-	// Register functions to be callable from JavaScript
-	js.Global().Set("goAdd", js.FuncOf(add))
-	js.Global().Set("goProcessData", js.FuncOf(processData))
-	
-	// Keep the program running
-	<-make(chan bool)
-}
-`;
-    
-    fs.writeFileSync(exampleGoFile, exampleGoContent);
-    console.log(`Created example Go file at ${exampleGoFile}`);
-    
-    // Add the new file to the list
-    goFiles.push('example.go');
-  }
-  
-  // Build each Go file
-  for (const goFile of goFiles) {
-    const goFilePath = join(goSourceDir, goFile);
-    const wasmFileName = goFile.replace('.go', '.wasm');
-    const wasmFilePath = join(wasmOutputDir, wasmFileName);
-    
-    console.log(`Building ${goFile} to ${wasmFilePath}`);
-    
-    try {
-      // Create a unique temporary directory with timestamp
-      const timestamp = Date.now();
-      const tempDir = join(os.tmpdir(), `go-wasm-build-${timestamp}`);
-      
-      // Ensure the directory is clean (doesn't exist from previous builds)
-      if (fs.existsSync(tempDir)) {
-        if (isWindows) {
-          // On Windows, we need to handle directory removal differently
-          execSync(`rmdir /s /q "${tempDir}"`, { shell: true });
-        } else {
-          fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-      }
-      
-      // Create the temporary directory
-      ensureDir(tempDir);
-      
-      // Copy the Go file to the temp directory
-      const tempGoFile = join(tempDir, goFile);
-      fs.copyFileSync(goFilePath, tempGoFile);
-      
-      // Initialize Go module
-      console.log(`Initializing Go module in ${tempDir}`);
-      execSync(`go mod init wasmapp`, { cwd: tempDir });
-      
-      // Build the WASM module with OS-specific command
-      if (isWindows) {
-        // Fix: Use Windows-specific environment variable setting
-        execSync(`go build -o "${wasmFilePath}" "${tempGoFile}"`, {
-          cwd: tempDir,
-          env: {
-            ...process.env,
-            GOOS: 'js',
-            GOARCH: 'wasm'
-          }
-        });
-      } else {
-        // Unix/Linux/Mac command
-        execSync(`GOOS=js GOARCH=wasm go build -o "${wasmFilePath}" "${tempGoFile}"`, {
-          cwd: tempDir
-        });
-      }
-      
-      // Clean up temporary directory
-      try {
-        if (isWindows) {
-          execSync(`rmdir /s /q "${tempDir}"`, { shell: true });
-        } else {
-          fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-      } catch (cleanupError) {
-        console.warn(`Warning: Failed to clean up temp directory ${tempDir}:`, cleanupError);
-      }
-      
-      console.log(`✓ Successfully built ${wasmFileName}`);
-    } catch (error) {
-      console.error(`✗ Error building ${goFile}:`);
-      console.error(error.message);
-      if (error.stdout) console.error(error.stdout.toString());
-      if (error.stderr) console.error(error.stderr.toString());
-    }
-  }
-}
-
-// Run the build process
-buildWasmModules().catch(error => {
-  console.error('Build failed:', error);
-  process.exit(1);
-});

package/templates/go-wasm-app/build.config.js

@@ -1,62 +0,0 @@
-// CommonJS/ESM compatible build configuration
-const buildConfig = {
-  /**
-   * Determines if we should build for dual module support
-   */
-  dualModuleSupport: true,
-  
-  /**
-   * Entry points for both client and server
-   */
-  entryPoints: {
-    client: 'src/client.js',
-    server: 'src/server.js'
-  },
-  
-  /**
-   * Output formats to generate
-   */
-  outputFormats: ['esm', 'cjs'],
-  
-  /**
-   * Output directory configuration
-   */
-  output: {
-    dir: 'dist',
-    client: {
-      esm: 'assets/[name].mjs',
-      cjs: 'assets/[name].js'
-    },
-    server: {
-      esm: 'server/[name].mjs',
-      cjs: 'server/[name].js'
-    }
-  },
-  
-  /**
-   * WebAssembly configuration
-   */
-  wasm: {
-    enabled: true,
-    goBinaryPath: 'go',
-    sourceDir: 'src/wasm',
-    outputDir: 'public/wasm',
-    copyGoRuntime: true
-  },
-  
-  /**
-   * Additional build options
-   */
-  options: {
-    minify: process.env.NODE_ENV === 'production',
-    sourcemap: true,
-    target: 'es2020'
-  }
-};
-
-// Make it work in both ESM and CommonJS environments
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = buildConfig;
-}
-
-export default buildConfig;

package/templates/go-wasm-app/build.js

@@ -1,218 +0,0 @@
-// Support both ESM and CommonJS imports
-const path = require('path');
-const fs = require('fs');
-const esbuild = require('esbuild');
-const { execSync } = require('child_process');
-const config = require('./build.config.js');
-
-// Define colors for console output
-const colors = {
-  reset: "\x1b[0m",
-  bright: "\x1b[1m",
-  dim: "\x1b[2m",
-  underscore: "\x1b[4m",
-  blink: "\x1b[5m",
-  cyan: "\x1b[36m",
-  green: "\x1b[32m",
-  yellow: "\x1b[33m",
-  red: "\x1b[31m"
-};
-
-// Helper for formatted console logs
-function log(message, type = 'info') {
-  const timestamp = new Date().toISOString().split('T')[1].split('.')[0];
-  const prefix = {
-    info: `${colors.bright}${colors.cyan}[INFO]${colors.reset}`,
-    success: `${colors.bright}${colors.green}[SUCCESS]${colors.reset}`,
-    warning: `${colors.bright}${colors.yellow}[WARNING]${colors.reset}`,
-    error: `${colors.bright}${colors.red}[ERROR]${colors.reset}`
-  };
-  
-  console.log(`${colors.dim}[${timestamp}]${colors.reset} ${prefix[type] || prefix.info} ${message}`);
-}
-
-// Main build function
-async function build() {
-  try {
-    log(`Starting build process (${process.env.NODE_ENV || 'development'} mode)`);
-    
-    // Ensure output directories
-    ensureDir(path.join(__dirname, 'dist'));
-    ensureDir(path.join(__dirname, 'dist/server'));
-    ensureDir(path.join(__dirname, 'dist/assets'));
-    ensureDir(path.join(__dirname, 'public/wasm'));
-    
-    // Build the WASM modules if enabled
-    if (config.wasm.enabled) {
-      await buildWasmModules();
-    }
-
-    // Build the client code
-    await buildClient();
-    
-    // Build the server code if it exists
-    if (fs.existsSync(path.join(__dirname, config.entryPoints.server))) {
-      await buildServer();
-    }
-
-    log('Build completed successfully', 'success');
-  } catch (error) {
-    log(`Build failed: ${error.message}`, 'error');
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-// Build WebAssembly modules
-async function buildWasmModules() {
-  const sourceDir = path.join(__dirname, config.wasm.sourceDir);
-  const outputDir = path.join(__dirname, config.wasm.outputDir);
-  
-  if (!fs.existsSync(sourceDir)) {
-    log(`WASM source directory not found: ${sourceDir}`, 'warning');
-    return;
-  }
-  
-  log('Building WebAssembly modules...');
-  
-  // Get all .go files that need to be compiled
-  const goFiles = fs.readdirSync(sourceDir)
-    .filter(file => file.endsWith('.go'));
-  
-  if (goFiles.length === 0) {
-    log('No Go files found to compile', 'warning');
-    return;
-  }
-  
-  // Compile each Go file to WASM
-  for (const goFile of goFiles) {
-    const goFilePath = path.join(sourceDir, goFile);
-    const wasmFileName = goFile.replace('.go', '.wasm');
-    const wasmFilePath = path.join(outputDir, wasmFileName);
-    
-    log(`Compiling ${goFile} to WebAssembly...`);
-    
-    try {
-      // Set environment variables for Go WASM compilation
-      const env = {
-        ...process.env,
-        GOOS: 'js',
-        GOARCH: 'wasm'
-      };
-      
-      // Compile Go to WASM
-      execSync(`${config.wasm.goBinaryPath} build -o "${wasmFilePath}" "${goFilePath}"`, {
-        env,
-        stdio: 'inherit'
-      });
-      
-      log(`Successfully compiled ${goFile} to ${wasmFileName}`, 'success');
-    } catch (error) {
-      log(`Failed to compile ${goFile}: ${error.message}`, 'error');
-      throw error;
-    }
-  }
-  
-  // Copy wasm_exec.js from Go installation to public folder
-  if (config.wasm.copyGoRuntime) {
-    try {
-      const goRoot = execSync(`${config.wasm.goBinaryPath} env GOROOT`, { encoding: 'utf8' }).trim();
-      const wasmExecSrc = path.join(goRoot, 'misc', 'wasm', 'wasm_exec.js');
-      const wasmExecDest = path.join(outputDir, 'wasm_exec.js');
-      
-      fs.copyFileSync(wasmExecSrc, wasmExecDest);
-      log('Copied wasm_exec.js runtime to public folder', 'success');
-    } catch (error) {
-      log(`Failed to copy wasm_exec.js: ${error.message}`, 'warning');
-    }
-  }
-}
-
-// Build client code with esbuild
-async function buildClient() {
-  const formats = config.dualModuleSupport ? config.outputFormats : ['esm'];
-  
-  for (const format of formats) {
-    const outfile = path.join(
-      __dirname, 
-      'dist', 
-      config.output.client[format].replace('[name]', 'client')
-    );
-    
-    log(`Building client bundle (${format})...`);
-    
-    await esbuild.build({
-      entryPoints: [path.join(__dirname, config.entryPoints.client)],
-      bundle: true,
-      outfile,
-      format,
-      platform: 'browser',
-      target: config.options.target,
-      minify: config.options.minify,
-      sourcemap: config.options.sourcemap,
-      define: {
-        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development'),
-        '__ESM__': format === 'esm' ? 'true' : 'false'
-      },
-      jsxFactory: 'jsx',
-      jsxFragment: 'Fragment',
-      banner: {
-        js: format === 'esm' 
-          ? `import { jsx, Fragment } from 'frontend-hamroun/jsx-runtime';` 
-          : `const { jsx, Fragment } = require('frontend-hamroun/jsx-runtime');`
-      }
-    });
-  }
-  
-  log('Client build completed', 'success');
-}
-
-// Build server code with esbuild
-async function buildServer() {
-  const formats = config.dualModuleSupport ? config.outputFormats : ['cjs'];
-  
-  for (const format of formats) {
-    const outfile = path.join(
-      __dirname, 
-      'dist', 
-      config.output.server[format].replace('[name]', 'server')
-    );
-    
-    log(`Building server bundle (${format})...`);
-    
-    await esbuild.build({
-      entryPoints: [path.join(__dirname, config.entryPoints.server)],
-      bundle: true,
-      outfile,
-      format,
-      platform: 'node',
-      target: config.options.target,
-      minify: config.options.minify,
-      sourcemap: config.options.sourcemap,
-      external: ['express', 'cors', 'path', 'fs', 'frontend-hamroun', 'frontend-hamroun/*'],
-      define: {
-        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development'),
-        '__ESM__': format === 'esm' ? 'true' : 'false'
-      }
-    });
-  }
-  
-  log('Server build completed', 'success');
-}
-
-// Utility to ensure directory exists
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-// Execute the build
-build();
-
-// Support both CommonJS and ESM
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = { build };
-}
-
-export { build };

package/templates/go-wasm-app/package.json

@@ -1,32 +0,0 @@
-{
-  "name": "go-wasm-app",
-  "version": "1.0.0",
-  "type": "commonjs",
-  "description": "Frontend Hamroun app with Go WebAssembly integration",
-  "scripts": {
-    "dev": "cross-env NODE_ENV=development node server.js",
-    "build": "cross-env NODE_ENV=production node build.js",
-    "build:wasm": "node build.js --wasm-only",
-    "start": "cross-env NODE_ENV=production node dist/server/server.js",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "express": "^4.18.2",
-    "frontend-hamroun": "latest"
-  },
-  "devDependencies": {
-    "cross-env": "^7.0.3",
-    "esbuild": "^0.19.5",
-    "nodemon": "^3.0.1",
-    "vitest": "^0.34.6"
-  },
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "exports": {
-    ".": {
-      "import": "./dist/assets/client.mjs",
-      "require": "./dist/assets/client.js"
-    }
-  }
-}