frontend-hamroun 1.2.79 → 1.2.82

package/templates/wasm/build-wasm.js

@@ -0,0 +1,228 @@
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const goDir = join(__dirname, 'go');
+const outputDir = join(__dirname, 'public');
+const wasmFile = join(outputDir, 'example.wasm');
+
+// Prevent infinite loops by checking if we're already running
+const lockFile = join(__dirname, '.build-lock');
+if (fs.existsSync(lockFile)) {
+  console.log('Build already in progress, skipping...');
+  process.exit(0);
+}
+
+// Create lock file
+fs.writeFileSync(lockFile, process.pid.toString());
+
+// Clean up lock file on exit
+process.on('exit', () => {
+  try {
+    fs.unlinkSync(lockFile);
+  } catch (e) {
+    // Ignore cleanup errors
+  }
+});
+
+process.on('SIGINT', () => {
+  try {
+    fs.unlinkSync(lockFile);
+  } catch (e) {
+    // Ignore cleanup errors
+  }
+  process.exit(0);
+});
+
+// Ensure public directory exists
+if (!fs.existsSync(outputDir)) {
+  fs.mkdirSync(outputDir, { recursive: true });
+}
+
+// Only create Go files if they don't exist (prevent infinite generation)
+if (!fs.existsSync(goDir) || !fs.existsSync(join(goDir, 'main.go'))) {
+  console.log('Creating Go WASM example files...');
+  fs.mkdirSync(goDir, { recursive: true });
+  
+  // Create the corrected Go main file with proper function names
+  const goMainContent = `package main
+
+import (
+	"fmt"
+	"strings"
+	"syscall/js"
+)
+
+func goHello(this js.Value, inputs []js.Value) interface{} {
+	name := inputs[0].String()
+	return fmt.Sprintf("Hello, %s from Go WASM!", name)
+}
+
+func goAdd(this js.Value, inputs []js.Value) interface{} {
+	a := inputs[0].Int()
+	b := inputs[1].Int()
+	return a + b
+}
+
+func goMultiply(this js.Value, inputs []js.Value) interface{} {
+	a := inputs[0].Float()
+	b := inputs[1].Float()
+	return a * b
+}
+
+func goFibonacci(this js.Value, inputs []js.Value) interface{} {
+	n := inputs[0].Int()
+	if n <= 1 {
+		return n
+	}
+	
+	a, b := 0, 1
+	for i := 2; i <= n; i++ {
+		a, b = b, a+b
+	}
+	return b
+}
+
+func goIsPrime(this js.Value, inputs []js.Value) interface{} {
+	n := inputs[0].Int()
+	if n < 2 {
+		return false
+	}
+	if n == 2 {
+		return true
+	}
+	if n%2 == 0 {
+		return false
+	}
+	
+	for i := 3; i*i <= n; i += 2 {
+		if n%i == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func main() {
+	fmt.Println("Go WASM initialized")
+	
+	// Register functions with correct names that match the frontend
+	js.Global().Set("goHello", js.FuncOf(goHello))
+	js.Global().Set("goAdd", js.FuncOf(goAdd))
+	js.Global().Set("goMultiply", js.FuncOf(goMultiply))
+	js.Global().Set("goFibonacci", js.FuncOf(goFibonacci))
+	js.Global().Set("goIsPrime", js.FuncOf(goIsPrime))
+	
+	fmt.Println("Go functions registered and ready!")
+	
+	// Keep the program running
+	select {}
+}
+`;
+  
+  fs.writeFileSync(join(goDir, 'main.go'), goMainContent);
+  
+  // Create go.mod file
+  const goModContent = `module wasm-example
+
+go 1.21
+`;
+  
+  fs.writeFileSync(join(goDir, 'go.mod'), goModContent);
+  
+  console.log('✅ Go example files created');
+} else {
+  console.log('Go files already exist, skipping creation');
+}
+
+console.log('Building Go WASM module...');
+
+// Set environment variables for WASM compilation
+const env = {
+  ...process.env,
+  GOOS: 'js',
+  GOARCH: 'wasm'
+};
+
+// Build command
+const buildArgs = ['build', '-o', wasmFile, 'main.go'];
+
+console.log(`Running: go ${buildArgs.join(' ')}`);
+console.log(`Working directory: ${goDir}`);
+console.log(`Output: ${wasmFile}`);
+
+const goProcess = spawn('go', buildArgs, {
+  cwd: goDir,
+  env: env,
+  stdio: 'inherit',
+  shell: true
+});
+
+goProcess.on('close', (code) => {
+  // Clean up lock file
+  try {
+    fs.unlinkSync(lockFile);
+  } catch (e) {
+    // Ignore cleanup errors
+  }
+  
+  if (code === 0) {
+    console.log('✅ Go WASM build successful!');
+    console.log(`📦 WASM file created: ${wasmFile}`);
+    
+    // Check if wasm_exec.js exists, if not, copy it
+    const wasmExecJs = join(outputDir, 'wasm_exec.js');
+    if (!fs.existsSync(wasmExecJs)) {
+      console.log('📋 Copying wasm_exec.js...');
+      
+      // Try to find wasm_exec.js in GOROOT
+      const findWasmExec = spawn('go', ['env', 'GOROOT'], {
+        stdio: 'pipe',
+        shell: true
+      });
+      
+      let goroot = '';
+      findWasmExec.stdout.on('data', (data) => {
+        goroot += data.toString().trim();
+      });
+      
+      findWasmExec.on('close', () => {
+        if (goroot) {
+          const wasmExecSource = join(goroot, 'misc', 'wasm', 'wasm_exec.js');
+          if (fs.existsSync(wasmExecSource)) {
+            fs.copyFileSync(wasmExecSource, wasmExecJs);
+            console.log('✅ wasm_exec.js copied successfully');
+          } else {
+            console.log('⚠️  wasm_exec.js not found, you may need to copy it manually');
+            console.log(`Expected location: ${wasmExecSource}`);
+          }
+        }
+      });
+    }
+  } else {
+    console.error('❌ Go WASM build failed with exit code:', code);
+    console.log('\n💡 Troubleshooting tips:');
+    console.log('1. Make sure Go is installed and in your PATH');
+    console.log('2. Check that your Go code in ./go/main.go is valid');
+    console.log('3. Ensure you have Go 1.11+ for WASM support');
+    process.exit(1);
+  }
+});
+
+goProcess.on('error', (error) => {
+  // Clean up lock file
+  try {
+    fs.unlinkSync(lockFile);
+  } catch (e) {
+    // Ignore cleanup errors
+  }
+  
+  console.error('❌ Failed to start Go build process:', error.message);
+  console.log('\n💡 Make sure Go is installed and available in your PATH');
+  console.log('Download Go from: https://golang.org/dl/');
+  process.exit(1);
+});

package/templates/wasm/esbuild.config.js

@@ -0,0 +1,63 @@
+import esbuild from 'esbuild';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Build client
+await esbuild.build({
+  entryPoints: ['src/client.tsx'],
+  bundle: true,
+  outfile: 'dist/client.js',
+  platform: 'browser',
+  format: 'esm',
+  minify: false,
+  jsx: 'transform',
+  jsxFactory: 'jsx',
+  jsxFragment: 'Fragment',
+  inject: ['./jsx-shim.js'],
+});
+
+// Build server
+await esbuild.build({
+  entryPoints: ['src/server.ts'],
+  bundle: true,
+  outfile: 'dist/server.js',
+  platform: 'node',
+  format: 'esm',
+  external: ['frontend-hamroun'],
+  packages: 'external',
+  minify: false,
+  jsx: 'transform',
+  jsxFactory: 'jsx',
+  jsxFragment: 'Fragment',
+  inject: ['./jsx-shim.js'],
+});
+
+const config = {
+  entryPoints: ['src/index.js'],
+  bundle: true,
+  outfile: 'dist/bundle.js',
+  format: 'esm',
+  target: 'es2020',
+  minify: process.env.NODE_ENV === 'production',
+  sourcemap: process.env.NODE_ENV !== 'production',
+  platform: 'browser',
+  loader: {
+    '.wasm': 'file'
+  },
+  external: [],
+  define: {
+    'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development')
+  }
+};
+
+if (process.argv.includes('--watch')) {
+  const ctx = await esbuild.context(config);
+  await ctx.watch();
+  console.log('Watching for changes...');
+} else {
+  await esbuild.build(config);
+  console.log('Build complete!');
+}

package/templates/wasm/go/main.go

@@ -0,0 +1,256 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"syscall/js"
+)
+
+// Global variable to hold JS values for complex data exchange
+var jsGlobal = js.Global()
+
+// Hello function - greeting with name
+func goHello(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("Error: goHello requires exactly 1 argument")
+	}
+
+	name := args[0].String()
+	result := fmt.Sprintf("Hello, %s from Go WASM!", name)
+
+	fmt.Printf("Go WASM: goHello('%s') = '%s'\n", name, result)
+	return js.ValueOf(result)
+}
+
+// Add function - simple arithmetic
+func goAdd(this js.Value, args []js.Value) interface{} {
+	if len(args) != 2 {
+		return js.ValueOf("Error: goAdd requires exactly 2 arguments")
+	}
+
+	a := args[0].Float()
+	b := args[1].Float()
+	result := a + b
+
+	fmt.Printf("Go WASM: goAdd(%f, %f) = %f\n", a, b, result)
+	return js.ValueOf(result)
+}
+
+// Multiply function - simple arithmetic
+func goMultiply(this js.Value, args []js.Value) interface{} {
+	if len(args) != 2 {
+		return js.ValueOf("Error: goMultiply requires exactly 2 arguments")
+	}
+
+	a := args[0].Float()
+	b := args[1].Float()
+	result := a * b
+
+	fmt.Printf("Go WASM: goMultiply(%f, %f) = %f\n", a, b, result)
+	return js.ValueOf(result)
+}
+
+// Fibonacci function - recursive computation
+func goFibonacci(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("Error: goFibonacci requires exactly 1 argument")
+	}
+
+	n := int(args[0].Float())
+	if n < 0 {
+		return js.ValueOf("Error: goFibonacci requires non-negative number")
+	}
+
+	result := fibonacciCalc(n)
+	fmt.Printf("Go WASM: goFibonacci(%d) = %d\n", n, result)
+	return js.ValueOf(result)
+}
+
+// Prime check function
+func goIsPrime(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("Error: goIsPrime requires exactly 1 argument")
+	}
+
+	n := int(args[0].Float())
+	if n < 2 {
+		return js.ValueOf(false)
+	}
+	if n == 2 {
+		return js.ValueOf(true)
+	}
+	if n%2 == 0 {
+		return js.ValueOf(false)
+	}
+
+	for i := 3; i*i <= n; i += 2 {
+		if n%i == 0 {
+			return js.ValueOf(false)
+		}
+	}
+
+	fmt.Printf("Go WASM: goIsPrime(%d) = %t\n", n, true)
+	return js.ValueOf(true)
+}
+
+// Helper function for fibonacci calculation
+func fibonacciCalc(n int) int {
+	if n <= 1 {
+		return n
+	}
+
+	a, b := 0, 1
+	for i := 2; i <= n; i++ {
+		a, b = b, a+b
+	}
+	return b
+}
+
+// Process array function - demonstrates array handling
+func goProcessArray(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("Error: goProcessArray requires exactly 1 argument")
+	}
+
+	jsArray := args[0]
+	if jsArray.Type() != js.TypeObject {
+		return js.ValueOf("Error: argument must be an array")
+	}
+
+	length := jsArray.Get("length").Int()
+	goSlice := make([]int, length)
+
+	// Convert JS array to Go slice
+	for i := 0; i < length; i++ {
+		goSlice[i] = int(jsArray.Index(i).Float())
+	}
+
+	// Process the slice (double each element and add index)
+	processedSlice := make([]interface{}, length)
+	for i, val := range goSlice {
+		processedSlice[i] = (val * 2) + i
+	}
+
+	fmt.Printf("Go WASM: goProcessArray([%s]) = [", strings.Trim(fmt.Sprint(goSlice), "[]"))
+	for i, val := range processedSlice {
+		if i > 0 {
+			fmt.Printf(" ")
+		}
+		fmt.Printf("%v", val)
+	}
+	fmt.Printf("]\n")
+
+	// Convert back to JS array
+	result := jsGlobal.Get("Array").New(length)
+	for i, val := range processedSlice {
+		result.SetIndex(i, val)
+	}
+
+	return result
+}
+
+// Calculate PI using series approximation
+func goCalculatePI(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("Error: goCalculatePI requires exactly 1 argument")
+	}
+
+	iterations := int(args[0].Float())
+	pi := 0.0
+
+	for i := 0; i < iterations; i++ {
+		term := 1.0 / float64(2*i+1)
+		if i%2 == 1 {
+			term = -term
+		}
+		pi += term
+	}
+
+	result := pi * 4
+	fmt.Printf("Go WASM: goCalculatePI(%d iterations) = %f\n", iterations, result)
+	return js.ValueOf(result)
+}
+
+// Performance benchmark function
+func goPerformanceBenchmark(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("Error: goPerformanceBenchmark requires exactly 1 argument")
+	}
+
+	iterations := int(args[0].Float())
+
+	// Simple computational benchmark
+	sum := 0
+	for i := 0; i < iterations; i++ {
+		sum += i * i
+	}
+
+	// Convert Go map to JS object
+	jsResult := jsGlobal.Get("Object").New()
+	jsResult.Set("iterations", js.ValueOf(iterations))
+	jsResult.Set("result", js.ValueOf(sum))
+	jsResult.Set("message", js.ValueOf(fmt.Sprintf("Completed %d iterations in Go WASM", iterations)))
+
+	fmt.Printf("Go WASM: goPerformanceBenchmark(%d) = %d\n", iterations, sum)
+	return jsResult
+}
+
+// String utilities function
+func goStringUtils(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("Error: goStringUtils requires exactly 1 argument")
+	}
+
+	input := args[0].String()
+
+	// Create result object with various string operations
+	result := jsGlobal.Get("Object").New()
+	result.Set("original", js.ValueOf(input))
+	result.Set("uppercase", js.ValueOf(strings.ToUpper(input)))
+	result.Set("lowercase", js.ValueOf(strings.ToLower(input)))
+	result.Set("reversed", js.ValueOf(reverseString(input)))
+	result.Set("length", js.ValueOf(len(input)))
+	result.Set("wordCount", js.ValueOf(len(strings.Fields(input))))
+
+	fmt.Printf("Go WASM: goStringUtils('%s') completed\n", input)
+	return result
+}
+
+// Helper function to reverse a string
+func reverseString(s string) string {
+	runes := []rune(s)
+	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)
+}
+
+// Initialize and register functions
+func main() {
+	fmt.Println("🚀 Go WASM module initializing...")
+
+	// Register all functions to the global JS scope with "go" prefix
+	jsGlobal.Set("goHello", js.FuncOf(goHello))
+	jsGlobal.Set("goAdd", js.FuncOf(goAdd))
+	jsGlobal.Set("goMultiply", js.FuncOf(goMultiply))
+	jsGlobal.Set("goFibonacci", js.FuncOf(goFibonacci))
+	jsGlobal.Set("goIsPrime", js.FuncOf(goIsPrime))
+	jsGlobal.Set("goProcessArray", js.FuncOf(goProcessArray))
+	jsGlobal.Set("goCalculatePI", js.FuncOf(goCalculatePI))
+	jsGlobal.Set("goPerformanceBenchmark", js.FuncOf(goPerformanceBenchmark))
+	jsGlobal.Set("goStringUtils", js.FuncOf(goStringUtils))
+
+	fmt.Println("✅ Go WASM functions registered:")
+	fmt.Println("   • goHello(name) - Greeting function")
+	fmt.Println("   • goAdd(a, b) - Addition")
+	fmt.Println("   • goMultiply(a, b) - Multiplication")
+	fmt.Println("   • goFibonacci(n) - Fibonacci sequence")
+	fmt.Println("   • goIsPrime(n) - Prime number check")
+	fmt.Println("   • goProcessArray(arr) - Array processing")
+	fmt.Println("   • goCalculatePI(iterations) - PI calculation")
+	fmt.Println("   • goPerformanceBenchmark(n) - Performance testing")
+	fmt.Println("   • goStringUtils(str) - String utilities")
+
+	// Keep the program running
+	select {}
+}

package/templates/wasm/index.html

@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Frontend Hamroun + Go WASM</title>
+  <style>
+    body {
+      margin: 0;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    }
+    
+    .loading-fallback {
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      flex-direction: column;
+      background: #f7f7f7;
+    }
+    
+    .loading-spinner {
+      width: 40px;
+      height: 40px;
+      border: 4px solid #f3f3f3;
+      border-top: 4px solid #007acc;
+      border-radius: 50%;
+      animation: spin 1s linear infinite;
+      margin-bottom: 20px;
+    }
+    
+    @keyframes spin {
+      0% { transform: rotate(0deg); }
+      100% { transform: rotate(360deg); }
+    }
+  </style>
+</head>
+<body>
+  <div id="app">
+    <div class="loading-fallback">
+      <div class="loading-spinner"></div>
+      <h2>Loading Frontend Hamroun + WASM...</h2>
+      <p>Initializing application and WebAssembly runtime...</p>
+    </div>
+  </div>
+  
+  <!-- Go WASM Runtime -->
+  <script src="/wasm_exec.js"></script>
+  
+  <!-- Application -->
+  <script type="module">
+    import { jsx, render } from 'frontend-hamroun';
+    import App from './src/App.tsx';
+    
+    // Wait for WASM runtime to be available
+    function waitForGo() {
+      return new Promise((resolve) => {
+        if (window.Go) {
+          resolve();
+        } else {
+          setTimeout(() => waitForGo().then(resolve), 50);
+        }
+      });
+    }
+    
+    async function startApp() {
+      try {
+        // Wait for Go WASM runtime
+        await waitForGo();
+        
+        // Render the app
+        const appElement = jsx(App, {});
+        render(appElement, document.getElementById('app'));
+      } catch (error) {
+        console.error('Failed to start app:', error);
+        document.getElementById('app').innerHTML = `
+          <div class="loading-fallback">
+            <h2 style="color: #dc2626;">Application Error</h2>
+            <p>Failed to initialize the application. Check the console for more details.</p>
+            <button onclick="window.location.reload()" style="
+              background: #007acc; 
+              color: white; 
+              border: none; 
+              padding: 10px 20px; 
+              border-radius: 5px; 
+              cursor: pointer;
+              margin-top: 10px;
+            ">Reload Page</button>
+          </div>
+        `;
+      }
+    }
+    
+    startApp();
+  </script>
+</body>
+</html>

package/templates/wasm/jsx-shim.js

@@ -0,0 +1,9 @@
+// JSX Runtime shim for Frontend Hamroun
+import { jsx, jsxs, Fragment } from 'frontend-hamroun';
+
+// Make JSX runtime available globally
+globalThis.jsx = jsx;
+globalThis.jsxs = jsxs;
+globalThis.Fragment = Fragment;
+
+export { jsx, jsxs, Fragment };