frontend-hamroun 1.2.80 → 1.2.82

package/templates/go/example.go

@@ -4,147 +4,202 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
+	"strconv"
+	"strings"
 	"syscall/js"
 )
 
-// Basic arithmetic functions
-func add(this js.Value, args []js.Value) interface{} {
+// 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{} {
 	if len(args) != 2 {
-		return js.ValueOf("Error: add requires 2 arguments")
+		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",
+		}
 	}
 
-	a := args[0].Int()
-	b := args[1].Int()
-	return js.ValueOf(a + b)
+	// Return the result
+	return fmt.Sprintf("%g", a+b)
 }
 
-func subtract(this js.Value, args []js.Value) interface{} {
+// goSubtract subtracts the second number from the first
+func goSubtract(this js.Value, args []js.Value) interface{} {
 	if len(args) != 2 {
-		return js.ValueOf("Error: subtract requires 2 arguments")
+		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",
+		}
 	}
 
-	a := args[0].Int()
-	b := args[1].Int()
-	return js.ValueOf(a - b)
+	// Return the result
+	return fmt.Sprintf("%g", a-b)
 }
 
-func multiply(this js.Value, args []js.Value) interface{} {
+// goMultiply multiplies two numbers
+func goMultiply(this js.Value, args []js.Value) interface{} {
 	if len(args) != 2 {
-		return js.ValueOf("Error: multiply requires 2 arguments")
+		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",
+		}
 	}
 
-	a := args[0].Int()
-	b := args[1].Int()
-	return js.ValueOf(a * b)
+	// Return the result
+	return fmt.Sprintf("%g", a*b)
 }
 
-// String operations
-func concat(this js.Value, args []js.Value) interface{} {
-	if len(args) < 1 {
-		return js.ValueOf("")
+// 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",
+		}
 	}
 
-	result := ""
-	for _, arg := range args {
-		result += arg.String()
+	// Check for division by zero
+	if b == 0 {
+		return map[string]interface{}{
+			"error": "Division by zero is not allowed",
+		}
 	}
-	return js.ValueOf(result)
+
+	// Return the result
+	return fmt.Sprintf("%g", a/b)
 }
 
-// JSON operations
-func parseJSON(this js.Value, args []js.Value) interface{} {
+// goReverseString reverses a string
+func goReverseString(this js.Value, args []js.Value) interface{} {
 	if len(args) != 1 {
-		return js.ValueOf("Error: parseJSON requires 1 argument")
+		return map[string]interface{}{
+			"error": "Expected 1 argument: string",
+		}
 	}
 
-	jsonStr := args[0].String()
-	var result interface{}
-	err := json.Unmarshal([]byte(jsonStr), &result)
-	if err != nil {
-		return js.ValueOf("Error parsing JSON: " + err.Error())
+	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]
 	}
 
-	// Convert result to JS value
-	return mapToJSValue(result)
+	return string(runes)
 }
 
-// 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))
+// 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",
 		}
-		return result
-	case []interface{}:
-		result := js.Global().Get("Array").New(len(v))
-		for i, val := range v {
-			result.SetIndex(i, 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 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))
 	}
-}
 
-// 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)
+	// Check for negative numbers
+	if n < 0 {
+		return map[string]interface{}{
+			"error": "Factorial is not defined for negative numbers",
+		}
 	}
-	return args[0] // Pass through
-}
 
-func __stringFromGo(this js.Value, args []js.Value) interface{} {
-	if len(args) != 1 {
-		return js.ValueOf("")
+	// Calculate factorial
+	result := int64(1)
+	for i := int64(2); i <= n; i++ {
+		result *= i
 	}
-	return args[0] // Pass through
+
+	return fmt.Sprintf("%d", result)
 }
 
-func __objectToGo(this js.Value, args []js.Value) interface{} {
-	if len(args) != 1 {
-		return js.ValueOf(-1)
+// 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",
+		}
 	}
-	return args[0] // Pass through
-}
 
-func __objectFromGo(this js.Value, args []js.Value) interface{} {
-	if len(args) != 1 {
-		return js.ValueOf("")
+	// 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))
 	}
-	return args[0] // Pass through
-}
 
-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
+	// Join the processed parts with commas
+	return strings.Join(results, ",")
 }

package/templates/ssr-template/esbuild.config.js

@@ -0,0 +1,33 @@
+import { build } from 'esbuild';
+
+// Build client
+await 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 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'],
+});
+
+console.log('Build completed successfully!');

package/templates/ssr-template/jsx-shim.js

@@ -0,0 +1 @@
+export { jsx, Fragment } from 'frontend-hamroun';

package/templates/ssr-template/package.json

@@ -1,16 +1,22 @@
-{
-  "name": "ssr-app",
-  "version": "0.1.0",
-  "type": "module",
-  "scripts": {
-    "dev": "node server.js",
-    "start": "node server.js",
-    "build": "echo 'No build step required for this template'"
-  },
-  "dependencies": {
-    "dotenv": "^16.0.3",
-    "express": "^4.18.2",
-    "frontend-hamroun": "latest",
-    "node-fetch": "^3.3.1"
-  }
-}
+{
+  "name": "ssr-version",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "build:client": "esbuild src/client.tsx --bundle --outfile=dist/client.js --platform=browser --format=esm",
+    "build:server": "esbuild src/server.ts --bundle --outfile=dist/server.js --platform=node --format=esm --external:frontend-hamroun --packages=external",
+    "build": "node esbuild.config.js",
+    "start": "node dist/server.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "frontend-hamroun": "latest"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/node": "^20.5.0",
+    "esbuild": "^0.19.12",
+    "typescript": "^5.0.0"
+  }
+}

package/templates/ssr-template/src/App.tsx

@@ -1,59 +1,19 @@
-import { useState, useEffect, useMemo, useRef, createContext } from 'frontend-hamroun';
-
-// Create a theme context
-const ThemeContext = createContext('light');
+import { useState } from 'frontend-hamroun';
 
 export function App() {
-  // Initialize with a default state that works on both server and client
   const [count, setCount] = useState(0);
-  const [theme, setTheme] = useState<'light' | 'dark'>('light');
-  const renderCount = useRef(0);
-  
-  // Client-side only effect
-  useEffect(() => {
-    if (typeof window !== 'undefined') {
-      renderCount.current += 1;
-      console.log('Component rendered', renderCount.current, 'times');
-    }
-    return () => console.log('Component unmounting');
-  }, [count]);
-  
-  // Memoized value
-  const doubled = useMemo(() => count * 2, [count]);
-  
+
+  const increment = () => setCount(count + 1);
+  const decrement = () => setCount(count - 1);
+
   return (
-    <ThemeContext.Provider value={theme}>
-      <div style={{ 
-        padding: '20px', 
-        backgroundColor: theme === 'dark' ? '#333' : '#fff',
-        color: theme === 'dark' ? '#fff' : '#333'
-      }}>
-        <h1>Server-Side Rendered App</h1>
-        <div>
-          <button 
-            onClick={() => setCount(count - 1)}
-            data-action="decrement"
-          >-</button>
-          <span style={{ margin: '0 10px' }}>{count}</span>
-          <button 
-            onClick={() => setCount(count + 1)}
-            data-action="increment"
-          >+</button>
-        </div>
-        <p>Doubled value: {doubled}</p>
-        {typeof window !== 'undefined' && (
-          <p>Render count: {renderCount.current}</p>
-        )}
-        <button 
-          onClick={() => setTheme(theme === 'light' ? 'dark' : 'light')}
-          style={{ marginTop: '10px' }}
-        >
-          Toggle Theme ({theme})
-        </button>
-        <script dangerouslySetInnerHTML={{
-          __html: `window.__INITIAL_STATE__ = ${JSON.stringify({ count: 0, theme: 'light' })};`
-        }} />
+    <div>
+      <h1>Server-Side Rendered App</h1>
+      <div>
+        <button onClick={decrement} data-action="decrement">-</button>
+        <span style={{ margin: '0 10px' }}>{count}</span>
+        <button onClick={increment} data-action="increment">+</button>
       </div>
-    </ThemeContext.Provider>
+    </div>
   );
 }

package/templates/ssr-template/src/client.tsx

@@ -1,18 +1,4 @@
-import { hydrate, createElement } from 'frontend-hamroun';
+import { hydrate, jsx } from 'frontend-hamroun';
+import { App } from './App.js';
 
-// For simplicity in this example, we just hydrate the root component
-// In a more complex app, you might use a router
-import HomePage from './pages/index';
-
-// When the DOM is ready, hydrate the server-rendered HTML
-document.addEventListener('DOMContentLoaded', () => {
-  const rootElement = document.getElementById('app');
-  
-  if (rootElement) {
-    // Hydrate the app with the same component that was rendered on the server
-    hydrate(<HomePage />, rootElement);
-    console.log('Hydration complete');
-  } else {
-    console.error('Could not find root element with id "app"');
-  }
-});
+hydrate(jsx(App, {}), document.getElementById('root')!);