frontend-hamroun 1.2.80 → 1.2.83

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 };