baraqex 1.0.76 → 2.0.0

package/templates/go/example.go

@@ -0,0 +1,205 @@
+//go:build js && wasm
+// +build js,wasm
+
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"syscall/js"
+)
+
+// Main function required for Go WebAssembly
+func main() {
+	// Set up global functions that will be accessible from JavaScript
+	js.Global().Set("goAdd", js.FuncOf(goAdd))
+	js.Global().Set("goSubtract", js.FuncOf(goSubtract))
+	js.Global().Set("goMultiply", js.FuncOf(goMultiply))
+	js.Global().Set("goDivide", js.FuncOf(goDivide))
+	js.Global().Set("goReverseString", js.FuncOf(goReverseString))
+	js.Global().Set("goCalculateFactorial", js.FuncOf(goCalculateFactorial))
+	js.Global().Set("goProcessArray", js.FuncOf(goProcessArray))
+
+	// Keep the Go program running until the context is done
+	// This is necessary for WebAssembly modules
+	<-make(chan bool)
+}
+
+// goAdd adds two numbers and returns the result
+func goAdd(this js.Value, args []js.Value) interface{} {
+	if len(args) != 2 {
+		return map[string]interface{}{
+			"error": "Expected 2 arguments: number, number",
+		}
+	}
+
+	// Parse string arguments as numbers
+	a, errA := strconv.ParseFloat(args[0].String(), 64)
+	b, errB := strconv.ParseFloat(args[1].String(), 64)
+
+	// Check for parsing errors
+	if errA != nil || errB != nil {
+		return map[string]interface{}{
+			"error": "Arguments must be valid numbers",
+		}
+	}
+
+	// Return the result
+	return fmt.Sprintf("%g", a+b)
+}
+
+// goSubtract subtracts the second number from the first
+func goSubtract(this js.Value, args []js.Value) interface{} {
+	if len(args) != 2 {
+		return map[string]interface{}{
+			"error": "Expected 2 arguments: number, number",
+		}
+	}
+
+	// Parse string arguments as numbers
+	a, errA := strconv.ParseFloat(args[0].String(), 64)
+	b, errB := strconv.ParseFloat(args[1].String(), 64)
+
+	// Check for parsing errors
+	if errA != nil || errB != nil {
+		return map[string]interface{}{
+			"error": "Arguments must be valid numbers",
+		}
+	}
+
+	// Return the result
+	return fmt.Sprintf("%g", a-b)
+}
+
+// goMultiply multiplies two numbers
+func goMultiply(this js.Value, args []js.Value) interface{} {
+	if len(args) != 2 {
+		return map[string]interface{}{
+			"error": "Expected 2 arguments: number, number",
+		}
+	}
+
+	// Parse string arguments as numbers
+	a, errA := strconv.ParseFloat(args[0].String(), 64)
+	b, errB := strconv.ParseFloat(args[1].String(), 64)
+
+	// Check for parsing errors
+	if errA != nil || errB != nil {
+		return map[string]interface{}{
+			"error": "Arguments must be valid numbers",
+		}
+	}
+
+	// Return the result
+	return fmt.Sprintf("%g", a*b)
+}
+
+// goDivide divides the first number by the second
+func goDivide(this js.Value, args []js.Value) interface{} {
+	if len(args) != 2 {
+		return map[string]interface{}{
+			"error": "Expected 2 arguments: number, number",
+		}
+	}
+
+	// Parse string arguments as numbers
+	a, errA := strconv.ParseFloat(args[0].String(), 64)
+	b, errB := strconv.ParseFloat(args[1].String(), 64)
+
+	// Check for parsing errors
+	if errA != nil || errB != nil {
+		return map[string]interface{}{
+			"error": "Arguments must be valid numbers",
+		}
+	}
+
+	// Check for division by zero
+	if b == 0 {
+		return map[string]interface{}{
+			"error": "Division by zero is not allowed",
+		}
+	}
+
+	// Return the result
+	return fmt.Sprintf("%g", a/b)
+}
+
+// goReverseString reverses a string
+func goReverseString(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return map[string]interface{}{
+			"error": "Expected 1 argument: string",
+		}
+	}
+
+	input := args[0].String()
+	runes := []rune(input)
+
+	// Reverse the string
+	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
+		runes[i], runes[j] = runes[j], runes[i]
+	}
+
+	return string(runes)
+}
+
+// goCalculateFactorial calculates the factorial of a number
+func goCalculateFactorial(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return map[string]interface{}{
+			"error": "Expected 1 argument: number",
+		}
+	}
+
+	// Parse string argument as number
+	n, err := strconv.ParseInt(args[0].String(), 10, 64)
+
+	// Check for parsing errors
+	if err != nil {
+		return map[string]interface{}{
+			"error": "Argument must be a valid integer",
+		}
+	}
+
+	// Check for negative numbers
+	if n < 0 {
+		return map[string]interface{}{
+			"error": "Factorial is not defined for negative numbers",
+		}
+	}
+
+	// Calculate factorial
+	result := int64(1)
+	for i := int64(2); i <= n; i++ {
+		result *= i
+	}
+
+	return fmt.Sprintf("%d", result)
+}
+
+// goProcessArray processes an array of values
+func goProcessArray(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 || args[0].Type() != js.TypeString {
+		return map[string]interface{}{
+			"error": "Expected 1 argument: comma-separated string",
+		}
+	}
+
+	// Split the input string by commas
+	input := args[0].String()
+	parts := strings.Split(input, ",")
+
+	// Process each part
+	var results []string
+	for _, part := range parts {
+		// Trim whitespace
+		trimmed := strings.TrimSpace(part)
+
+		// Convert to uppercase and add to results
+		results = append(results, strings.ToUpper(trimmed))
+	}
+
+	// Join the processed parts with commas
+	return strings.Join(results, ",")
+}

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

@@ -0,0 +1,38 @@
+# 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

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

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

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

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