frontend-hamroun 1.2.65 → 1.2.67

package/bin/cli.js

@@ -149,13 +149,15 @@ async function chooseTemplate() {
     'basic-app': '🚀',
     'ssr-template': '🌐',
     'fullstack-app': '⚡',
+    'go-wasm-app': '🔄',
   };
 
   // Detailed descriptions
   const templateDescriptions = {
     'basic-app': 'Single-page application with just the essentials. Perfect for learning the framework or building simple apps.',
     'ssr-template': 'Server-side rendered application with hydration. Optimized for SEO and fast initial load.',
-    'fullstack-app': 'Complete solution with API routes, authentication, and database integration ready to go.'
+    'fullstack-app': 'Complete solution with API routes, authentication, and database integration ready to go.',
+    'go-wasm-app': 'WebAssembly integration with Go for high-performance computing in the browser and Node.js.'
   };
   
   console.log(boxen(
@@ -165,7 +167,8 @@ async function chooseTemplate() {
       const shortDesc = {
         'basic-app': 'Simple client-side application',
         'ssr-template': 'Server-side rendering with hydration',
-        'fullstack-app': 'Complete fullstack application with API'
+        'fullstack-app': 'Complete fullstack application with API',
+        'go-wasm-app': 'Go WebAssembly application'
       }[template] || 'Application template';
       
       return `${icon} ${chalk.cyan(template)}\n   ${chalk.dim(shortDesc)}`;
@@ -253,6 +256,23 @@ async function chooseTemplate() {
         '• Full production applications',
         '• Apps needing authentication',
         '• Projects requiring database integration'
+      ],
+      'go-wasm-app': [
+        `${chalk.bold('Go WASM App Template')} ${templateIcons['go-wasm-app']}`,
+        '',
+        `${chalk.dim('WebAssembly integration with Go programming language.')}`,
+        '',
+        `${chalk.yellow('Features:')}`,
+        '• Go + WebAssembly integration',
+        '• High-performance computation in browser',
+        '• Server-side WASM processing',
+        '• Shared code between Go and JavaScript',
+        '• Optimized build pipeline',
+        '',
+        `${chalk.yellow('Best for:')}`,
+        '• Computation-heavy applications',
+        '• Projects requiring Go libraries',
+        '• Performance-critical features'
       ]
     }[answers.template] || ['No detailed information available for this template'];
     
@@ -765,6 +785,174 @@ program
     console.log("The dev:tools command has been improved in your version.");
   });
 
+// Add Go WASM specific command
+program
+  .command('add:wasm [name]')
+  .description('Create a new WebAssembly module with Go')
+  .option('-p, --path <path>', 'Path where the Go WASM module should be created')
+  .option('-t, --type <type>', 'Type of WASM module (go, rust, c)', 'go')
+  .action(async (moduleName, options) => {
+    displayBanner();
+    createSection('Create Go WASM Module');
+    
+    // Validate Go installation
+    const goInstalled = await checkGo();
+    if (!goInstalled) {
+      console.log(chalk.red('Go must be installed to create WASM modules.'));
+      console.log(chalk.yellow(`Please install Go from ${terminalLink('https://golang.org/dl/', 'https://golang.org/dl/')}`));
+      return;
+    }
+    
+    // Get module name if not provided
+    if (!moduleName) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'moduleName',
+          message: chalk.green('What is your WASM module name?'),
+          default: 'gomodule',
+          validate: input =>
+            /^[a-z0-9-_]+$/.test(input)
+              ? true
+              : 'Module name can only contain lowercase letters, numbers, hyphens, and underscores'
+        }
+      ]);
+      moduleName = answers.moduleName;
+    }
+    
+    // Get module path
+    let modulePath = options.path;
+    if (!modulePath) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'path',
+          message: chalk.green('Where do you want to create this Go WASM module?'),
+          default: 'src/wasm',
+          validate: input => /^[a-zA-Z0-9-_/\\]+$/.test(input) 
+            ? true 
+            : 'Path can only contain letters, numbers, slashes, hyphens and underscores'
+        }
+      ]);
+      modulePath = answers.path;
+    }
+    
+    // Choose Go module capabilities
+    const capabilities = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'features',
+        message: chalk.green('Select module capabilities:'),
+        choices: [
+          { name: 'Basic Functions (add, subtract, etc.)', value: 'basic', checked: true },
+          { name: 'JSON Processing', value: 'json', checked: true },
+          { name: 'Complex Calculations', value: 'complex' },
+          { name: 'Data Compression', value: 'compression' },
+          { name: 'String Operations', value: 'string' }
+        ]
+      }
+    ]);
+    
+    // Generate the module
+    const spinner = ora({
+      text: `Creating Go WASM module ${moduleName}...`,
+      color: 'cyan'
+    }).start();
+    
+    try {
+      const fullPath = path.join(process.cwd(), modulePath);
+      await fs.ensureDir(fullPath);
+      
+      // Copy example.go with appropriate modifications
+      const sourceFile = path.join(__dirname, '..', 'templates', 'go', 'example.go');
+      const destFile = path.join(fullPath, `${moduleName}.go`);
+      
+      await fs.copy(sourceFile, destFile);
+      
+      // Create build files
+      const buildBatFile = path.join(fullPath, 'build.bat');
+      const buildShFile = path.join(fullPath, 'build.sh');
+      
+      // Create build.bat
+      await fs.writeFile(buildBatFile, `@echo off
+echo Building ${moduleName} Go WASM module...
+
+set GOOS=js
+set GOARCH=wasm
+go build -o ${moduleName}.wasm ${moduleName}.go
+
+if %ERRORLEVEL% NEQ 0 (
+    echo Error: Failed to build Go WASM module
+    exit /b 1
+)
+
+for /f "tokens=*" %%g in ('go env GOROOT') do (set GOROOT=%%g)
+copy "%GOROOT%\\misc\\wasm\\wasm_exec.js" .
+
+echo Build complete!
+`);
+      
+      // Create build.sh
+      await fs.writeFile(buildShFile, `#!/bin/bash
+echo "Building ${moduleName} Go WASM module..."
+
+GOOS=js GOARCH=wasm go build -o ${moduleName}.wasm ${moduleName}.go
+
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to build Go WASM module"
+    exit 1
+fi
+
+GOROOT=$(go env GOROOT)
+cp "$GOROOT/misc/wasm/wasm_exec.js" .
+
+echo "Build complete!"
+`);
+      
+      // Make build.sh executable
+      try {
+        await fs.chmod(buildShFile, 0o755);
+      } catch (error) {
+        console.log(chalk.yellow('Note: Could not make build.sh executable. You may need to run "chmod +x build.sh" manually.'));
+      }
+      
+      spinner.succeed(`Go WASM module created at ${chalk.green(fullPath)}`);
+      
+      // Show usage instructions
+      console.log(boxen(
+        `${chalk.bold.green('Go WASM Module Created Successfully!')}\n\n` +
+        `${chalk.bold('To build the WASM module:')}\n` +
+        chalk.cyan(`  cd ${path.relative(process.cwd(), fullPath)}\n`) +
+        chalk.cyan(`  ${process.platform === 'win32' ? 'build.bat' : './build.sh'}\n\n`) +
+        `${chalk.bold('To use in your code:')}\n` +
+        chalk.cyan(`import { loadGoWasm } from 'frontend-hamroun';\n\n`) +
+        chalk.cyan(`// Load the WASM module\n`) +
+        chalk.cyan(`const wasm = await loadGoWasm('/${path.basename(modulePath)}/${moduleName}.wasm');\n\n`) +
+        chalk.cyan(`// Call a function\n`) +
+        chalk.cyan(`const result = wasm.functions.goAdd(5, 7);\n`),
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: 'round',
+          borderColor: 'green'
+        }
+      ));
+    } catch (error) {
+      spinner.fail(`Failed to create Go WASM module`);
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+// Helper function to check if Go is installed
+async function checkGo() {
+  try {
+    await execAsync('go version');
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
 // Default command when no arguments
 if (process.argv.length <= 2) {
   showDashboard();

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export { batchUpdates } from './batch';
 export { jsx, jsxs, Fragment } from './jsx-runtime';
 export { render, hydrate } from './renderer';
 export { renderToString } from './server-renderer';
+export { loadGoWasm, createTypedWasmFunction, goValues } from './wasm';
+export type { GoWasmInstance, GoWasmOptions } from './wasm';
 export type { Context } from './context';
 export type { VNode } from './types';
 export type { Server, ServerConfig, User, DbConfig, MiddlewareFunction } from './server-types';

package/dist/wasm.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Go WebAssembly Integration Utilities
+ *
+ * This module provides tools for loading and interacting with Go WASM modules
+ * in browser and server environments.
+ */
+export interface GoWasmInstance {
+    instance: WebAssembly.Instance;
+    module: WebAssembly.Module;
+    exports: any;
+    functions: Record<string, Function>;
+}
+export interface GoWasmOptions {
+    importObject?: WebAssembly.Imports;
+    goWasmPath?: string;
+    loadGo?: boolean;
+    onLoad?: (instance: GoWasmInstance) => void;
+    debug?: boolean;
+}
+/**
+ * Load a Go WASM module from a URL
+ */
+export declare function loadGoWasm(wasmUrl: string, options?: GoWasmOptions): Promise<GoWasmInstance>;
+/**
+ * Create a TypeScript-friendly wrapper for Go WASM functions
+ */
+export declare function createTypedWasmFunction<T extends (...args: any[]) => any>(instance: GoWasmInstance, functionName: string): T;
+/**
+ * Helper to convert JavaScript values to Go-compatible formats
+ */
+export declare const goValues: {
+    stringToGo: (instance: GoWasmInstance, str: string) => number;
+    stringFromGo: (instance: GoWasmInstance, ptr: number) => string;
+    objectToGo: (instance: GoWasmInstance, obj: any) => number;
+    objectFromGo: (instance: GoWasmInstance, ptr: number) => any;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frontend-hamroun",
-  "version": "1.2.65",
+  "version": "1.2.67",
   "description": "A lightweight full-stack JavaScript framework",
   "type": "module",
   "main": "./dist/index.js",

package/templates/go/README.md

@@ -0,0 +1,150 @@
+# Go WebAssembly Integration
+
+This directory contains tools and examples for integrating Go with Frontend Hamroun via WebAssembly (WASM).
+
+## Getting Started
+
+### Prerequisites
+
+1. Go 1.16+ installed on your system
+2. Basic understanding of Go programming language
+
+### Compiling Go to WebAssembly
+
+To compile a Go file to WebAssembly for browser usage:
+
+```bash
+GOOS=js GOARCH=wasm go build -o mymodule.wasm myfile.go
+```
+
+For optimized production builds:
+
+```bash
+GOOS=js GOARCH=wasm go build -ldflags="-s -w" -o mymodule.wasm myfile.go
+```
+
+### Required Files
+
+Copy these files to your project:
+
+1. `wasm_exec.js` - for browser usage
+2. `wasm_exec_node.js` - for Node.js (server-side) usage
+
+You can find these files in your Go installation:
+- Browser: `$(go env GOROOT)/misc/wasm/wasm_exec.js`
+- Node.js: `$(go env GOROOT)/misc/wasm/wasm_exec_node.js`
+
+## Usage Examples
+
+### Browser Usage
+
+```jsx
+import { loadGoWasm, createTypedWasmFunction } from 'frontend-hamroun';
+
+function GoCalculator() {
+  const [result, setResult] = useState(0);
+  const [wasmInstance, setWasmInstance] = useState(null);
+  
+  useEffect(() => {
+    async function loadWasm() {
+      const instance = await loadGoWasm('/mymodule.wasm', {
+        goWasmPath: '/wasm_exec.js', // Path to the Go runtime JS file
+        debug: true
+      });
+      
+      setWasmInstance(instance);
+    }
+    
+    loadWasm();
+  }, []);
+  
+  const handleCalculate = () => {
+    if (wasmInstance) {
+      // Call Go function from WASM
+      const goAdd = createTypedWasmFunction<(a: number, b: number) => number>(
+        wasmInstance,
+        'goAdd'
+      );
+      
+      const sum = goAdd(5, 7);
+      setResult(sum);
+    }
+  };
+  
+  return (
+    <div>
+      <button onClick={handleCalculate}>Calculate 5 + 7</button>
+      <p>Result: {result}</p>
+    </div>
+  );
+}
+```
+
+### Server Usage
+
+```js
+import { loadGoWasmFromFile } from 'frontend-hamroun/server';
+import path from 'path';
+
+export async function get(req, res) {
+  const wasmPath = path.join(process.cwd(), 'lib', 'mymodule.wasm');
+  
+  try {
+    const wasm = await loadGoWasmFromFile(wasmPath);
+    
+    // Call Go function
+    const result = wasm.functions.goProcessData({
+      values: [1, 2, 3, 4, 5],
+      operation: 'sum'
+    });
+    
+    res.json(JSON.parse(result));
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+}
+```
+
+## Advanced Usage
+
+### Passing Complex Data Between JavaScript and Go
+
+For complex data types, use JSON serialization:
+
+```go
+// In Go
+func processData(this js.Value, args []js.Value) interface{} {
+  // Get JSON string from JS
+  jsonStr := args[0].String()
+  
+  // Parse JSON
+  var data map[string]interface{}
+  json.Unmarshal([]byte(jsonStr), &data)
+  
+  // Process data...
+  
+  // Return as JSON string
+  resultJSON, _ := json.Marshal(result)
+  return js.ValueOf(string(resultJSON))
+}
+```
+
+```js
+// In JavaScript
+const dataToProcess = { items: [1, 2, 3], config: { name: "test" } };
+const jsonStr = JSON.stringify(dataToProcess);
+const resultJson = wasmInstance.functions.processData(jsonStr);
+const result = JSON.parse(resultJson);
+```
+
+## Performance Considerations
+
+- WebAssembly functions run in the same thread as JavaScript
+- For CPU-intensive tasks, consider using Web Workers
+- Go's garbage collector can cause occasional pauses
+- Large WASM files can increase initial load time
+
+## Resources
+
+- [Go WebAssembly Wiki](https://github.com/golang/go/wiki/WebAssembly)
+- [Frontend Hamroun Documentation](https://github.com/hamroun/frontend-hamroun)

package/templates/go/build.bat

@@ -0,0 +1,36 @@
+@echo off
+echo Building Go WASM module...
+
+REM Check if Go is installed
+where go >nul 2>&1
+if %ERRORLEVEL% NEQ 0 (
+    echo Error: Go is not installed
+    exit /b 1
+)
+
+REM Build WASM module
+set GOOS=js
+set GOARCH=wasm
+go build -o example.wasm example.go
+if %ERRORLEVEL% NEQ 0 (
+    echo Error: Failed to build Go WASM module
+    exit /b 1
+)
+
+REM Copy wasm_exec.js files
+for /f "tokens=*" %%g in ('go env GOROOT') do (set GOROOT=%%g)
+
+echo Copying WASM runtime files from %GOROOT%\misc\wasm\
+copy "%GOROOT%\misc\wasm\wasm_exec.js" .
+copy "%GOROOT%\misc\wasm\wasm_exec_node.js" .
+
+echo Build complete!
+echo Files created:
+echo - example.wasm - WebAssembly module
+echo - wasm_exec.js - Browser runtime
+echo - wasm_exec_node.js - Node.js runtime
+
+echo.
+echo Usage:
+echo 1. Copy these files to your project's public directory
+echo 2. Load the WASM module using the provided utilities

package/templates/go/build.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+# Build script for Go WASM modules
+
+# Ensure Go is installed
+if ! command -v go &> /dev/null; then
+    echo "Error: Go is not installed"
+    exit 1
+fi
+
+# Check Go version
+GO_VERSION=$(go version | cut -d ' ' -f 3 | sed 's/go//')
+GO_VERSION_MAJOR=$(echo $GO_VERSION | cut -d '.' -f 1)
+GO_VERSION_MINOR=$(echo $GO_VERSION | cut -d '.' -f 2)
+
+if [ $GO_VERSION_MAJOR -lt 1 ] || ([ $GO_VERSION_MAJOR -eq 1 ] && [ $GO_VERSION_MINOR -lt 16 ]); then
+    echo "Warning: Go version 1.16+ recommended for WebAssembly, detected $GO_VERSION"
+fi
+
+# Build example WASM module
+echo "Building example Go WASM module..."
+GOOS=js GOARCH=wasm go build -o example.wasm example.go
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to build Go WASM module"
+    exit 1
+fi
+
+# Copy wasm_exec.js files for browser and Node.js from Go installation
+GO_ROOT=$(go env GOROOT)
+echo "Copying wasm_exec.js files from $GO_ROOT/misc/wasm/"
+cp "$GO_ROOT/misc/wasm/wasm_exec.js" ./
+cp "$GO_ROOT/misc/wasm/wasm_exec_node.js" ./
+
+echo "Build complete!"
+echo "Files created:"
+echo "- example.wasm - WebAssembly module"
+echo "- wasm_exec.js - Browser runtime"
+echo "- wasm_exec_node.js - Node.js runtime"
+
+echo ""
+echo "Usage:"
+echo "1. Copy these files to your project's public directory"
+echo "2. Load the WASM module using the provided utilities"

package/templates/go/example.go

@@ -0,0 +1,137 @@
+//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)
+}
+
+// Helper to convert Go string to JS string
+func stringToJS(s string) js.Value {
+	return js.ValueOf(s)
+}
+
+// Helper to convert JS string to Go string
+func stringFromJS(jsStr js.Value) string {
+	return jsStr.String()
+}
+
+// Helper to convert Go object to JS object (via JSON)
+func objectToJS(obj interface{}) js.Value {
+	data, err := json.Marshal(obj)
+	if err != nil {
+		return js.ValueOf("Error: Failed to marshal JSON")
+	}
+	return stringToJS(string(data))
+}
+
+// Helper to convert JS object to Go object (via JSON)
+func objectFromJS(jsObj js.Value) (interface{}, error) {
+	jsonStr := jsObj.String()
+	var result interface{}
+	err := json.Unmarshal([]byte(jsonStr), &result)
+	return result, err
+}
+
+// Complex example: process 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))
+}
+
+// Helper functions exposed to JavaScript
+func registerHelperFunctions() {
+	js.Global().Set("__stringToGo", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+		if len(args) != 1 {
+			return nil
+		}
+		return stringToJS(stringFromJS(args[0]))
+	}))
+
+	js.Global().Set("__stringFromGo", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+		if len(args) != 1 {
+			return nil
+		}
+		return stringToJS(stringFromJS(args[0]))
+	}))
+
+	js.Global().Set("__objectToGo", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+		if len(args) != 1 {
+			return nil
+		}
+		obj, _ := objectFromJS(args[0])
+		return objectToJS(obj)
+	}))
+
+	js.Global().Set("__objectFromGo", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+		if len(args) != 1 {
+			return nil
+		}
+		return stringToJS(stringFromJS(args[0]))
+	}))
+}
+
+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))
+
+	// Register helper functions
+	registerHelperFunctions()
+
+	// Keep the program running
+	<-make(chan bool)
+}