frontend-hamroun 1.2.65 → 1.2.66

package/templates/go-wasm-app/.tmp-wasm-build/example.go

@@ -0,0 +1,75 @@
+//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)
+}

package/templates/go-wasm-app/.tmp-wasm-build/go.mod

@@ -0,0 +1,3 @@
+module wasmapp
+
+go 1.23.6

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

@@ -0,0 +1,21 @@
+# Frontend Hamroun - Go WebAssembly Template
+
+This template demonstrates integration between Frontend Hamroun and Go WebAssembly for high-performance web applications.
+
+## Features
+
+- 🔄 Go + WebAssembly integration
+- ⚡ High-performance computation in the browser
+- 🔍 Typed API for Go WASM functions
+- 🔧 Automated build process for Go code
+- 🧩 Example Go WASM modules and usage
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) (v14+)
+- [Go](https://golang.org/dl/) (v1.16+)
+
+## Getting Started
+
+1. Install dependencies:
+   

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

@@ -0,0 +1,218 @@
+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;
+  }
+}
+
+// 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 output directory if it doesn't exist
+  if (!fs.existsSync(wasmOutputDir)) {
+    fs.mkdirSync(wasmOutputDir, { recursive: true });
+  }
+  
+  // Get the Go root directory
+  const goRoot = execSync('go env GOROOT', { encoding: 'utf8' }).trim();
+  
+  // Copy the wasm_exec.js file to the output directory
+  const wasmExecJsPath = join(goRoot, 'misc', 'wasm', 'wasm_exec.js');
+  const wasmExecJsDest = join(wasmOutputDir, 'wasm_exec.js');
+  
+  console.log(`Copying ${wasmExecJsPath} to ${wasmExecJsDest}`);
+  fs.copyFileSync(wasmExecJsPath, wasmExecJsDest);
+  
+  // Build all Go files in the WASM directory
+  if (fs.existsSync(goSourceDir)) {
+    const goFiles = fs.readdirSync(goSourceDir)
+      .filter(file => file.endsWith('.go'));
+    
+    if (goFiles.length === 0) {
+      console.log('No Go files found in src/wasm');
+      return;
+    }
+    
+    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)) {
+          fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        
+        fs.mkdirSync(tempDir, { recursive: true });
+        
+        // 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: Windows command without spaces in environment variables
+          // and using environment object instead of command-line args
+          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
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        
+        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());
+      }
+    }
+  } else {
+    console.log(`Go source directory ${goSourceDir} not found, creating it...`);
+    fs.mkdirSync(goSourceDir, { recursive: true });
+    
+    // Create an example Go file if the directory is empty
+    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}`);
+    
+    // Build the example file
+    console.log('Building example Go file...');
+    buildWasmModules();
+  }
+}
+
+// Run the build process
+buildWasmModules().catch(error => {
+  console.error('Build failed:', error);
+  process.exit(1);
+});