frontend-hamroun 1.2.79 → 1.2.80

package/templates/go/example.go

@@ -4,202 +4,147 @@
 package main
 
 import (
+	"encoding/json"
 	"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{} {
+// Basic arithmetic functions
+func add(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 js.ValueOf("Error: add requires 2 arguments")
 	}
 
-	// Return the result
-	return fmt.Sprintf("%g", a+b)
+	a := args[0].Int()
+	b := args[1].Int()
+	return js.ValueOf(a + b)
 }
 
-// goSubtract subtracts the second number from the first
-func goSubtract(this js.Value, args []js.Value) interface{} {
+func subtract(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 js.ValueOf("Error: subtract requires 2 arguments")
 	}
 
-	// Return the result
-	return fmt.Sprintf("%g", a-b)
+	a := args[0].Int()
+	b := args[1].Int()
+	return js.ValueOf(a - b)
 }
 
-// goMultiply multiplies two numbers
-func goMultiply(this js.Value, args []js.Value) interface{} {
+func multiply(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 js.ValueOf("Error: multiply requires 2 arguments")
 	}
 
-	// Return the result
-	return fmt.Sprintf("%g", a*b)
+	a := args[0].Int()
+	b := args[1].Int()
+	return js.ValueOf(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",
-		}
+// String operations
+func concat(this js.Value, args []js.Value) interface{} {
+	if len(args) < 1 {
+		return js.ValueOf("")
 	}
 
-	// Check for division by zero
-	if b == 0 {
-		return map[string]interface{}{
-			"error": "Division by zero is not allowed",
-		}
+	result := ""
+	for _, arg := range args {
+		result += arg.String()
 	}
-
-	// Return the result
-	return fmt.Sprintf("%g", a/b)
+	return js.ValueOf(result)
 }
 
-// goReverseString reverses a string
-func goReverseString(this js.Value, args []js.Value) interface{} {
+// JSON operations
+func parseJSON(this js.Value, args []js.Value) interface{} {
 	if len(args) != 1 {
-		return map[string]interface{}{
-			"error": "Expected 1 argument: string",
-		}
+		return js.ValueOf("Error: parseJSON requires 1 argument")
 	}
 
-	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]
+	jsonStr := args[0].String()
+	var result interface{}
+	err := json.Unmarshal([]byte(jsonStr), &result)
+	if err != nil {
+		return js.ValueOf("Error parsing JSON: " + err.Error())
 	}
 
-	return string(runes)
+	// Convert result to JS value
+	return mapToJSValue(result)
 }
 
-// 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",
+// Helper functions for JSON conversion
+func mapToJSValue(value interface{}) js.Value {
+	switch v := value.(type) {
+	case map[string]interface{}:
+		result := js.Global().Get("Object").New()
+		for key, val := range v {
+			result.Set(key, mapToJSValue(val))
 		}
-	}
-
-	// 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",
+		return result
+	case []interface{}:
+		result := js.Global().Get("Array").New(len(v))
+		for i, val := range v {
+			result.SetIndex(i, mapToJSValue(val))
 		}
+		return result
+	case string:
+		return js.ValueOf(v)
+	case float64:
+		return js.ValueOf(v)
+	case bool:
+		return js.ValueOf(v)
+	case nil:
+		return js.ValueOf(nil)
+	default:
+		return js.ValueOf(fmt.Sprint(v))
 	}
+}
 
-	// Check for negative numbers
-	if n < 0 {
-		return map[string]interface{}{
-			"error": "Factorial is not defined for negative numbers",
-		}
+// Special utility functions for string handling between Go and JS
+func __stringToGo(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf(-1)
 	}
+	return args[0] // Pass through
+}
 
-	// Calculate factorial
-	result := int64(1)
-	for i := int64(2); i <= n; i++ {
-		result *= i
+func __stringFromGo(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("")
 	}
-
-	return fmt.Sprintf("%d", result)
+	return args[0] // Pass through
 }
 
-// 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",
-		}
+func __objectToGo(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf(-1)
 	}
+	return args[0] // Pass through
+}
 
-	// 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))
+func __objectFromGo(this js.Value, args []js.Value) interface{} {
+	if len(args) != 1 {
+		return js.ValueOf("")
 	}
+	return args[0] // Pass through
+}
 
-	// Join the processed parts with commas
-	return strings.Join(results, ",")
+func main() {
+	fmt.Println("Go WebAssembly module initialized")
+
+	// Register functions to make available to JavaScript
+	js.Global().Set("goAdd", js.FuncOf(add))
+	js.Global().Set("goSubtract", js.FuncOf(subtract))
+	js.Global().Set("goMultiply", js.FuncOf(multiply))
+	js.Global().Set("goConcat", js.FuncOf(concat))
+	js.Global().Set("goParseJSON", js.FuncOf(parseJSON))
+
+	// Register special utility functions for frontend-hamroun integration
+	js.Global().Set("__stringToGo", js.FuncOf(__stringToGo))
+	js.Global().Set("__stringFromGo", js.FuncOf(__stringFromGo))
+	js.Global().Set("__objectToGo", js.FuncOf(__objectToGo))
+	js.Global().Set("__objectFromGo", js.FuncOf(__objectFromGo))
+
+	// Keep the program running
+	c := make(chan struct{}, 0)
+	fmt.Println("Go WebAssembly module ready")
+	<-c
 }

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

@@ -1,11 +1,9 @@
-const config = {
+export default {
   presets: [
     ['@babel/preset-env', {
       targets: {
         node: 'current'
-      },
-      // Enable dynamic imports for both ESM and CommonJS
-      modules: false
+      }
     }]
   ],
   plugins: [
@@ -15,7 +13,3 @@ const config = {
     }]
   ]
 };
-
-// Support both ESM and CommonJS
-export default config;
-module.exports = config;

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

@@ -1,32 +1,23 @@
 {
   "name": "go-wasm-app",
   "version": "1.0.0",
-  "type": "commonjs",
-  "description": "Frontend Hamroun app with Go WebAssembly integration",
+  "description": "WebAssembly integration with Go for Frontend Hamroun with SSR",
+  "type": "module",
+  "main": "server.js",
   "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"
+    "build:wasm": "node build-wasm.js",
+    "prepare": "node -e \"if (!require('fs').existsSync('public/wasm')) { require('fs').mkdirSync('public/wasm', {recursive: true}); }\"",
+    "dev": "npm run build:wasm && node --watch server.js",
+    "build": "npm run build:wasm && node -e \"require('fs').mkdirSync('dist', {recursive: true}); require('fs-extra').copySync('public', 'dist')\"",
+    "start": "cross-env NODE_ENV=production node server.js"
   },
   "dependencies": {
     "express": "^4.18.2",
-    "frontend-hamroun": "latest"
+    "frontend-hamroun": "^1.2.71",
+    "fs-extra": "^10.0.0"
   },
   "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"
-    }
+    "@babel/core": "^7.22.9",
+    "cross-env": "^7.0.3"
   }
 }