frontend-hamroun 1.2.74 → 1.2.77

package/dist/wasm.mjs

@@ -0,0 +1,103 @@
+const p = "/wasm_exec.js";
+async function F(o, t = {}) {
+  const {
+    importObject: s = {},
+    goWasmPath: c = p,
+    loadGo: W = !0,
+    onLoad: _,
+    debug: l = !1
+  } = t;
+  typeof window < "u" && W && await y(c);
+  try {
+    const e = typeof Go < "u" ? new Go() : null;
+    l && console.log(`[WASM] Loading module from ${o}`);
+    const a = await fetch(o);
+    if (!a.ok)
+      throw new Error(`Failed to fetch WASM module: ${a.statusText}`);
+    const b = await a.arrayBuffer(), G = await WebAssembly.compile(b), A = e ? {
+      ...e.importObject,
+      ...s
+    } : s, w = await WebAssembly.instantiate(G, A);
+    e && e.run(w);
+    const d = w.exports, r = {};
+    for (const n in d)
+      if (typeof d[n] == "function") {
+        const m = d[n];
+        if (r[n] = (...i) => m(...i), l) {
+          const i = r[n];
+          r[n] = (...f) => {
+            console.log(`[WASM] Calling ${n}(${f.join(", ")})`);
+            const u = i(...f);
+            return console.log(`[WASM] ${n} returned:`, u), u;
+          };
+        }
+      }
+    if (typeof window < "u") {
+      for (const n in window)
+        if (n.startsWith("go") && typeof window[n] == "function") {
+          const m = window[n];
+          if (r[n] = (...i) => m(...i), l) {
+            const i = r[n];
+            r[n] = (...f) => {
+              console.log(`[WASM] Calling global ${n}(${f.join(", ")})`);
+              const u = i(...f);
+              return console.log(`[WASM] ${n} returned:`, u), u;
+            };
+          }
+        }
+    }
+    const g = {
+      instance: w,
+      module: G,
+      exports: d,
+      functions: r
+    };
+    return _ && _(g), g;
+  } catch (e) {
+    throw console.error("[WASM] Failed to load Go WASM module:", e), e;
+  }
+}
+async function y(o = p) {
+  if (!(typeof window > "u") && !(typeof window.Go < "u"))
+    return new Promise((t, s) => {
+      const c = document.createElement("script");
+      c.src = o, c.onload = () => t(), c.onerror = () => s(new Error(`Failed to load Go WASM runtime from ${o}`)), document.head.appendChild(c);
+    });
+}
+function S(o, t) {
+  if (!o.functions[t])
+    throw new Error(`WASM function "${t}" not found`);
+  return o.functions[t];
+}
+const M = {
+  // Convert JS string to Go string (returns memory pointer)
+  stringToGo: (o, t) => {
+    if (!o.functions.__stringToGo)
+      throw new Error("__stringToGo function not found in WASM module");
+    return o.functions.__stringToGo(t);
+  },
+  // Convert Go string (memory pointer) to JS string
+  stringFromGo: (o, t) => {
+    if (!o.functions.__stringFromGo)
+      throw new Error("__stringFromGo function not found in WASM module");
+    return o.functions.__stringFromGo(t);
+  },
+  // Convert JS object to Go (returns memory pointer)
+  objectToGo: (o, t) => {
+    if (!o.functions.__objectToGo)
+      throw new Error("__objectToGo function not found in WASM module");
+    return o.functions.__objectToGo(JSON.stringify(t));
+  },
+  // Convert Go object (memory pointer) to JS object
+  objectFromGo: (o, t) => {
+    if (!o.functions.__objectFromGo)
+      throw new Error("__objectFromGo function not found in WASM module");
+    const s = o.functions.__objectFromGo(t);
+    return JSON.parse(s);
+  }
+};
+export {
+  S as createTypedWasmFunction,
+  M as goValues,
+  F as loadGoWasm
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frontend-hamroun",
-  "version": "1.2.74",
+  "version": "1.2.77",
   "description": "A lightweight full-stack JavaScript framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,62 +22,63 @@
     },
     "./server": {
       "types": "./dist/server/index.d.ts",
-      "import": "./dist/server/index.js",
+      "node": "./dist/server/index.js",
+      "import": "./dist/server/index.mjs",
       "require": "./dist/server/index.js"
     },
     "./server/database": {
       "types": "./dist/server/database.d.ts",
-      "import": "./dist/server/database.js",
+      "import": "./dist/server/database.mjs",
       "require": "./dist/server/database.js"
     },
     "./server/auth": {
       "types": "./dist/server/auth.d.ts",
-      "import": "./dist/server/auth.js",
+      "import": "./dist/server/auth.mjs",
       "require": "./dist/server/auth.js"
     },
     "./server/middleware": {
       "types": "./dist/server/middleware.d.ts",
-      "import": "./dist/server/middleware.js",
+      "import": "./dist/server/middleware.mjs",
       "require": "./dist/server/middleware.js"
     },
     "./server/api-router": {
       "types": "./dist/server/api-router.d.ts",
-      "import": "./dist/server/api-router.js",
+      "import": "./dist/server/api-router.mjs",
       "require": "./dist/server/api-router.js"
     },
     "./server-types": {
       "types": "./dist/server-types.d.ts",
-      "import": "./dist/server-types.js",
+      "import": "./dist/server-types.mjs",
       "require": "./dist/server-types.js"
     },
     "./ssr": {
       "types": "./dist/server-renderer.d.ts",
-      "import": "./dist/server-renderer.js",
+      "import": "./dist/server-renderer.mjs",
       "require": "./dist/server-renderer.js"
     },
     "./jsx-runtime": {
       "types": "./dist/jsx-runtime.d.ts",
-      "import": "./dist/jsx-runtime.js",
+      "import": "./dist/jsx-runtime.mjs",
       "require": "./dist/jsx-runtime.js"
     },
     "./hooks": {
       "types": "./dist/hooks.d.ts",
-      "import": "./dist/hooks.js",
+      "import": "./dist/hooks.mjs",
       "require": "./dist/hooks.js"
     },
     "./renderer": {
       "types": "./dist/renderer.d.ts",
-      "import": "./dist/renderer.js",
+      "import": "./dist/renderer.mjs",
       "require": "./dist/renderer.js"
     },
     "./wasm": {
       "types": "./dist/wasm.d.ts",
-      "import": "./dist/wasm.js",
+      "import": "./dist/wasm.mjs",
       "require": "./dist/wasm.js"
     },
     "./server/wasm": {
       "types": "./dist/server/wasm.d.ts",
-      "import": "./dist/server/wasm.js",
+      "import": "./dist/server/wasm.mjs",
       "require": "./dist/server/wasm.js"
     }
   },

package/templates/complete-app/build.js

@@ -0,0 +1,284 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import esbuild from 'esbuild';
+import http from 'http';
+import { fileURLToPath } from 'url';
+
+// Get __dirname equivalent in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ANSI color codes for console output
+const colors = {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m"
+};
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const isProduction = process.env.NODE_ENV === 'production';
+const wasmOnly = args.includes('--wasm-only');
+const serve = args.includes('--serve');
+
+// Helper for logging with colors
+function log(message, type = 'info') {
+  const prefix = {
+    info: `${colors.bright}${colors.cyan}[INFO]${colors.reset}`,
+    success: `${colors.bright}${colors.green}[SUCCESS]${colors.reset}`,
+    warning: `${colors.bright}${colors.yellow}[WARNING]${colors.reset}`,
+    error: `${colors.bright}${colors.red}[ERROR]${colors.reset}`
+  };
+  
+  console.log(`${prefix[type] || prefix.info} ${message}`);
+}
+
+// Build configuration
+const config = {
+  // Entry points
+  entryPoints: {
+    client: 'src/client.js',
+    server: 'src/server.js'
+  },
+  
+  // Output directories
+  outDir: {
+    client: 'dist/public',
+    server: 'dist'
+  },
+  
+  // WASM configuration
+  wasm: {
+    dir: 'src/wasm',
+    buildScript: process.platform === 'win32' ? 'build.bat' : './build.sh',
+    outputDir: 'dist/public/wasm'
+  }
+};
+
+// Build WASM modules if they exist
+async function buildWasmModules() {
+  const wasmDir = path.join(__dirname, config.wasm.dir);
+  
+  if (!fs.existsSync(wasmDir)) {
+    log('No WASM directory found, skipping WASM build', 'warning');
+    return;
+  }
+  
+  log('Building WebAssembly modules...');
+  
+  try {
+    // Execute build script in WASM directory
+    execSync(config.wasm.buildScript, {
+      cwd: wasmDir,
+      stdio: 'inherit'
+    });
+    
+    // Ensure output directory exists
+    const outputDir = path.join(__dirname, config.wasm.outputDir);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+    
+    // Copy WASM files to output directory
+    const wasmFiles = fs.readdirSync(wasmDir).filter(file => 
+      file.endsWith('.wasm') || file === 'wasm_exec.js');
+    
+    for (const file of wasmFiles) {
+      fs.copyFileSync(
+        path.join(wasmDir, file),
+        path.join(outputDir, file)
+      );
+    }
+    
+    log(`WebAssembly modules built and copied to ${config.wasm.outputDir}`, 'success');
+  } catch (error) {
+    log(`Failed to build WebAssembly modules: ${error.message}`, 'error');
+    if (!wasmOnly) {
+      log('Continuing with rest of build...', 'warning');
+    } else {
+      process.exit(1);
+    }
+  }
+}
+
+// Build client-side code
+async function buildClient() {
+  log('Building client bundle...');
+  
+  try {
+    const clientOutDir = path.join(__dirname, config.outDir.client);
+    
+    // Ensure output directory exists
+    if (!fs.existsSync(clientOutDir)) {
+      fs.mkdirSync(clientOutDir, { recursive: true });
+    }
+    
+    // Bundle client code
+    await esbuild.build({
+      entryPoints: [path.join(__dirname, config.entryPoints.client)],
+      bundle: true,
+      outfile: path.join(clientOutDir, 'client.js'),
+      format: 'esm',
+      platform: 'browser',
+      target: ['es2020'],
+      minify: isProduction,
+      sourcemap: !isProduction,
+      define: {
+        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development')
+      },
+      loader: {
+        '.js': 'jsx',
+        '.jsx': 'jsx'
+      }
+    });
+    
+    // Copy index.html if it exists
+    const indexPath = path.join(__dirname, 'src/index.html');
+    if (fs.existsSync(indexPath)) {
+      fs.copyFileSync(indexPath, path.join(clientOutDir, 'index.html'));
+    }
+    
+    log('Client bundle built successfully', 'success');
+  } catch (error) {
+    log(`Failed to build client bundle: ${error.message}`, 'error');
+    process.exit(1);
+  }
+}
+
+// Build server-side code
+async function buildServer() {
+  log('Building server bundle...');
+  
+  try {
+    const serverOutDir = path.join(__dirname, config.outDir.server);
+    
+    // Ensure output directory exists
+    if (!fs.existsSync(serverOutDir)) {
+      fs.mkdirSync(serverOutDir, { recursive: true });
+    }
+    
+    // Bundle server code
+    await esbuild.build({
+      entryPoints: [path.join(__dirname, config.entryPoints.server)],
+      bundle: true,
+      outfile: path.join(serverOutDir, 'server.js'),
+      format: 'esm',
+      platform: 'node',
+      target: ['node16'],
+      minify: isProduction,
+      sourcemap: !isProduction,
+      define: {
+        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'development')
+      },
+      loader: {
+        '.js': 'jsx',
+        '.jsx': 'jsx'
+      },
+      external: ['express', 'frontend-hamroun', 'compression', 'cors', 'path', 'fs', 'http', 'socket.io']
+    });
+    
+    log('Server bundle built successfully', 'success');
+  } catch (error) {
+    log(`Failed to build server bundle: ${error.message}`, 'error');
+    process.exit(1);
+  }
+}
+
+// Copy static assets like CSS, images, etc.
+function copyStaticAssets() {
+  log('Copying static assets...');
+  
+  const publicDir = path.join(__dirname, 'public');
+  const outputDir = path.join(__dirname, config.outDir.client);
+  
+  if (fs.existsSync(publicDir)) {
+    // Recursive function to copy directory contents
+    function copyDir(src, dest) {
+      // Create destination directory if it doesn't exist
+      if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+      }
+      
+      // Read all files in source directory
+      const entries = fs.readdirSync(src, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        
+        if (entry.isDirectory()) {
+          // Recursively copy subdirectories
+          copyDir(srcPath, destPath);
+        } else {
+          // Copy files
+          fs.copyFileSync(srcPath, destPath);
+        }
+      }
+    }
+    
+    copyDir(publicDir, outputDir);
+    log('Static assets copied successfully', 'success');
+  } else {
+    log('No static assets to copy (public directory not found)', 'warning');
+  }
+}
+
+// Start a development server
+async function startDevServer() {
+  log('Starting development server...');
+  
+  // Import server module
+  try {
+    // Use dynamic import because this is ESM
+    const serverModule = await import('./dist/server.js');
+    log('Server started. Press Ctrl+C to stop.', 'success');
+  } catch (error) {
+    log(`Failed to start development server: ${error.message}`, 'error');
+    process.exit(1);
+  }
+}
+
+// Main build function
+async function build() {
+  console.log('\n' + '='.repeat(60));
+  log(`Building ${isProduction ? 'production' : 'development'} bundle...`);
+  console.log('='.repeat(60) + '\n');
+  
+  try {
+    // Build WASM first
+    await buildWasmModules();
+    
+    // If wasm-only flag is provided, exit after building WASM
+    if (wasmOnly) {
+      log('WASM-only build completed', 'success');
+      return;
+    }
+    
+    // Build client and server code
+    await Promise.all([
+      buildClient(),
+      buildServer()
+    ]);
+    
+    // Copy static assets
+    copyStaticAssets();
+    
+    log('Build completed successfully', 'success');
+    
+    // Start development server if requested
+    if (serve) {
+      await startDevServer();
+    }
+  } catch (error) {
+    log(`Build failed: ${error.message}`, 'error');
+    process.exit(1);
+  }
+}
+
+// Run the build
+build();

package/templates/complete-app/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "complete-app",
+  "version": "1.0.0",
+  "description": "Complete Frontend Hamroun App with all features: SSR, WASM, API routes, and more",
+  "type": "module",
+  "scripts": {
+    "dev": "cross-env NODE_ENV=development node build.js --serve",
+    "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.js",
+    "test": "vitest run",
+    "wasm:build": "cd src/wasm && ./build.sh"
+  },
+  "dependencies": {
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "frontend-hamroun": "latest",
+    "jsonwebtoken": "^9.0.2",
+    "socket.io": "^4.7.2"
+  },
+  "devDependencies": {
+    "@types/compression": "^1.7.3",
+    "@types/cors": "^2.8.14",
+    "@types/express": "^4.17.18",
+    "@types/jsonwebtoken": "^9.0.3",
+    "@types/node": "^20.8.2",
+    "autoprefixer": "^10.4.14",
+    "chokidar": "^3.5.3",
+    "cross-env": "^7.0.3",
+    "esbuild": "^0.19.5",
+    "postcss": "^8.4.27",
+    "tailwindcss": "^3.3.3",
+    "vitest": "^0.34.6"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}