gowm 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 Toutes les modifications notables de ce projet seront documentées dans ce fichier.
 
+## [1.0.2] - 2025-05-29
+
+### Corrigé
+- **Problème critique de bundling** : Correction de l'importation des modules Node.js `fs` et `path` qui causaient des erreurs avec Webpack 5 et autres bundlers modernes
+- Importation dynamique sécurisée des modules Node.js pour éviter les erreurs de build
+- Amélioration de la détection d'environnement (Node.js vs navigateur)
+- Ajout de méthode `ensureNodeModules()` pour un chargement sûr des dépendances Node.js
+
+### Ajouté
+- Version sécurisée du loader (`loader-safe.js`) avec gestion d'erreurs améliorée
+- Meilleure compatibilité avec les bundlers modernes (Webpack 5, Vite, etc.)
+
+## [1.0.1] - 2025-05-29
+
+### Corrigé
+- **Compatibilité navigateur** : Résolution du problème avec les modules Node.js `fs` et `path` qui empêchaient l'utilisation dans React/Vue/navigateur
+- Importation conditionnelle des modules Node.js uniquement en environnement serveur
+- Ajout de points d'entrée séparés pour Node.js et navigateur dans `package.json`
+- Création de versions navigateur dédiées (`loader-browser.js`, `bridge-browser.js`, `browser.js`)
+
+### Ajouté
+- Support ES modules pour les environnements navigateur
+- Configuration `package.json` avec champs `browser`, `module`, et `exports`
+- Documentation sur la résolution du problème de compatibilité (`BROWSER_SUPPORT.md`)
+
 ## [1.0.0] - 2025-05-28
 
 ### Ajouté

package/package.json

@@ -1,9 +1,21 @@
 {
     "name": "gowm",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "Go WebAssembly Manager - Simplifiez l'intégration de modules WebAssembly Go dans vos projets JavaScript",
     "main": "src/index.js",
+    "browser": "src/browser.js",
+    "module": "src/browser.js",
     "types": "types/index.d.ts",
+    "exports": {
+        ".": {
+            "node": "./src/index.js",
+            "browser": "./src/browser.js",
+            "import": "./src/browser.js",
+            "require": "./src/index.js"
+        },
+        "./hooks": "./hooks/useWasm.js",
+        "./composables": "./composables/useWasm.js"
+    },
     "files": [
         "src/",
         "types/",
@@ -49,4 +61,4 @@
     "devDependencies": {
         "@types/node": "^20.0.0"
     }
-}
+}

package/src/bridge-browser.js

@@ -0,0 +1,157 @@
+export default class WasmBridge {
+    constructor(wasmModule, options = {}) {
+        this.module = wasmModule;
+        this.callbacks = new Map();
+        this.name = options.name || 'unnamed';
+    }
+
+    // Appel de fonction avec gestion d'erreurs
+    call(funcName, ...args) {
+        try {
+            // Vérifier d'abord dans les exports WASM
+            if (this.module.exports && this.module.exports[funcName]) {
+                return this.module.exports[funcName](...args);
+            }
+            // Puis dans les fonctions globales JavaScript (pour Go WASM)
+            else if (globalThis[funcName] && typeof globalThis[funcName] === 'function') {
+                return globalThis[funcName](...args);
+            }
+            else {
+                throw new Error(`Function ${funcName} not found`);
+            }
+        } catch (error) {
+            console.error(`Error calling ${funcName}:`, error);
+            throw error;
+        }
+    }
+
+    // Appel asynchrone de fonction
+    async callAsync(funcName, ...args) {
+        return new Promise((resolve, reject) => {
+            try {
+                const result = this.call(funcName, ...args);
+                if (result instanceof Promise) {
+                    result.then(resolve).catch(reject);
+                } else {
+                    resolve(result);
+                }
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    // Créer un buffer en mémoire WASM
+    createBuffer(data) {
+        let buffer;
+        let size;
+
+        if (data instanceof Float64Array) {
+            buffer = data;
+            size = data.length * 8; // 8 bytes par float64
+        } else if (data instanceof Uint8Array) {
+            buffer = data;
+            size = data.length;
+        } else if (typeof data === 'string') {
+            const encoder = new TextEncoder();
+            buffer = encoder.encode(data);
+            size = buffer.length;
+        } else {
+            throw new Error('Unsupported data type for buffer');
+        }
+
+        // Allouer de la mémoire dans WASM
+        const ptr = this.call('malloc', size);
+        if (!ptr) {
+            throw new Error('Failed to allocate memory in WASM');
+        }
+
+        // Copier les données dans la mémoire WASM
+        const wasmMemory = new Uint8Array(this.module.exports.memory.buffer, ptr, size);
+        wasmMemory.set(buffer);
+
+        return {
+            ptr,
+            buffer: wasmMemory,
+            size,
+            free: () => {
+                try {
+                    this.call('free', ptr);
+                } catch (e) {
+                    // Ignorer les erreurs de libération
+                }
+            }
+        };
+    }
+
+    // Enregistrer un callback JavaScript appelable depuis WASM
+    registerCallback(name, callback) {
+        this.callbacks.set(name, callback);
+        globalThis[`__gowm_callback_${name}`] = callback;
+    }
+
+    // Désinscrire un callback
+    unregisterCallback(name) {
+        this.callbacks.delete(name);
+        delete globalThis[`__gowm_callback_${name}`];
+    }
+
+    // Obtenir la liste des fonctions disponibles
+    getAvailableFunctions() {
+        const functions = [];
+
+        // Fonctions exports WASM
+        if (this.module.exports) {
+            Object.keys(this.module.exports).forEach(key => {
+                if (typeof this.module.exports[key] === 'function') {
+                    functions.push(key);
+                }
+            });
+        }
+
+        // Fonctions globales (pour Go WASM)
+        Object.keys(globalThis).forEach(key => {
+            if (typeof globalThis[key] === 'function' && !key.startsWith('__gowm_')) {
+                functions.push(key);
+            }
+        });
+
+        return [...new Set(functions)].sort();
+    }
+
+    // Vérifier si une fonction existe
+    hasFunction(funcName) {
+        return (
+            (this.module.exports && typeof this.module.exports[funcName] === 'function') ||
+            (typeof globalThis[funcName] === 'function')
+        );
+    }
+
+    // Obtenir les statistiques du module
+    getStats() {
+        return {
+            ready: this.module.ready,
+            functions: this.getAvailableFunctions(),
+            callbacks: Array.from(this.callbacks.keys()),
+            memoryUsage: this.module.exports.memory ? this.module.exports.memory.buffer.byteLength : 0,
+            name: this.name
+        };
+    }
+
+    // Nettoyage des ressources
+    cleanup() {
+        // Désinscrire tous les callbacks
+        for (const name of this.callbacks.keys()) {
+            this.unregisterCallback(name);
+        }
+
+        // Arrêter le runtime Go si possible
+        if (this.module.go && typeof this.module.go.exit === 'function') {
+            try {
+                this.module.go.exit(0);
+            } catch (e) {
+                // Ignorer les erreurs
+            }
+        }
+    }
+}

package/src/browser.js

@@ -0,0 +1,77 @@
+// Version navigateur de GOWM sans dépendances Node.js
+import WasmLoader from './loader-browser.js';
+import WasmBridge from './bridge-browser.js';
+
+class GoWM {
+    constructor() {
+        this.loader = new WasmLoader();
+        this.modules = new Map();
+    }
+
+    async load(wasmPath, options = {}) {
+        const module = await this.loader.loadModule(wasmPath, options);
+        const bridge = new WasmBridge(module, options);
+
+        const moduleId = options.name || 'default';
+        this.modules.set(moduleId, { module, bridge });
+
+        return bridge;
+    }
+
+    get(name = 'default') {
+        const entry = this.modules.get(name);
+        return entry ? entry.bridge : null;
+    }
+
+    async loadFromNPM(packageName, options = {}) {
+        // Pour le navigateur, on assume que le fichier est dans /wasm/{packageName}.wasm
+        const wasmPath = `/wasm/${packageName}.wasm`;
+        return this.load(wasmPath, { ...options, name: packageName });
+    }
+
+    unload(name = 'default') {
+        const entry = this.modules.get(name);
+        if (entry) {
+            entry.bridge.cleanup();
+            this.loader.unloadModule(name);
+            return this.modules.delete(name);
+        }
+        return false;
+    }
+
+    listModules() {
+        return Array.from(this.modules.keys());
+    }
+
+    getStats() {
+        const stats = {};
+        for (const [name, entry] of this.modules) {
+            stats[name] = entry.bridge.getStats();
+        }
+        return stats;
+    }
+
+    unloadAll() {
+        for (const name of this.modules.keys()) {
+            this.unload(name);
+        }
+    }
+}
+
+// Instance globale
+const gowm = new GoWM();
+
+// API simplifiée
+export const load = (wasmPath, options) => gowm.load(wasmPath, options);
+export const get = (name) => gowm.get(name);
+export const loadFromNPM = (packageName, options) => gowm.loadFromNPM(packageName, options);
+export const unload = (name) => gowm.unload(name);
+export const listModules = () => gowm.listModules();
+export const getStats = () => gowm.getStats();
+export const unloadAll = () => gowm.unloadAll();
+
+// Export des classes
+export { GoWM, WasmLoader, WasmBridge };
+
+// Export par défaut
+export default gowm;

package/src/loader-browser.js

@@ -0,0 +1,113 @@
+export default class WasmLoader {
+    constructor() {
+        this.modules = new Map();
+        this.isNode = false; // Toujours faux en environnement navigateur
+    }
+
+    async loadModule(wasmPath, options = {}) {
+        const moduleId = options.name || wasmPath.split('/').pop().replace('.wasm', '');
+
+        if (this.modules.has(moduleId)) {
+            return this.modules.get(moduleId);
+        }
+
+        try {
+            // Charger wasm_exec.js si nécessaire
+            if (!globalThis.Go) {
+                await this.loadGoRuntime(options.goRuntimePath);
+            }
+
+            const go = new globalThis.Go();
+
+            const response = await fetch(wasmPath);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch WASM file: ${response.status} ${response.statusText}`);
+            }
+            const wasmBytes = await response.arrayBuffer();
+
+            const result = await WebAssembly.instantiate(wasmBytes, go.importObject);
+
+            // Pré-initialisation pour optimiser les performances
+            if (options.preInit !== false) {
+                // Démarrer Go en arrière-plan pour éviter le blocage
+                go.run(result.instance);
+
+                // Attendre que le module soit prêt
+                await this.waitForReady(moduleId);
+            }
+
+            const module = {
+                instance: result.instance,
+                go: go,
+                exports: result.instance.exports,
+                ready: true
+            };
+
+            this.modules.set(moduleId, module);
+            return module;
+
+        } catch (error) {
+            throw new Error(`Failed to load WASM module ${moduleId}: ${error.message}`);
+        }
+    }
+
+    async waitForReady(moduleId, timeout = 5000) {
+        const startTime = Date.now();
+
+        return new Promise((resolve, reject) => {
+            const checkReady = () => {
+                // Vérifier plusieurs signaux de prêt
+                const isReady = globalThis.__gowm_ready ||
+                    (globalThis.Go && globalThis.Go._initialized) ||
+                    (globalThis.add && typeof globalThis.add === 'function');
+
+                if (isReady || Date.now() - startTime > timeout) {
+                    if (isReady) {
+                        resolve();
+                    } else {
+                        reject(new Error(`Module ${moduleId} failed to initialize within ${timeout}ms`));
+                    }
+                } else {
+                    setTimeout(checkReady, 10);
+                }
+            };
+            checkReady();
+        });
+    }
+
+    async loadGoRuntime(customPath) {
+        const runtimePath = customPath || '/wasm_exec.js';
+        await this.loadScript(runtimePath);
+    }
+
+    loadScript(src) {
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = src;
+            script.onload = resolve;
+            script.onerror = reject;
+            document.head.appendChild(script);
+        });
+    }
+
+    getModule(name) {
+        return this.modules.get(name);
+    }
+
+    unloadModule(name) {
+        const module = this.modules.get(name);
+        if (module && module.go) {
+            // Nettoyage des ressources Go
+            try {
+                module.go.exit(0);
+            } catch (e) {
+                // Ignorer les erreurs de nettoyage
+            }
+        }
+        return this.modules.delete(name);
+    }
+
+    listModules() {
+        return Array.from(this.modules.keys());
+    }
+}

package/src/loader-safe.js

@@ -0,0 +1,184 @@
+// Version sécurisée du loader qui évite les problèmes de bundling
+class WasmLoader {
+    constructor() {
+        this.modules = new Map();
+        this.isNode = typeof window === 'undefined';
+        this.nodeModulesLoaded = false;
+        this.fs = null;
+        this.path = null;
+    }
+
+    async ensureNodeModules() {
+        if (this.isNode && !this.nodeModulesLoaded) {
+            try {
+                // Import dynamique pour éviter les problèmes avec les bundlers
+                this.fs = await this.dynamicRequire('fs');
+                this.path = await this.dynamicRequire('path');
+                this.nodeModulesLoaded = true;
+            } catch (error) {
+                console.warn('Failed to load Node.js modules:', error.message);
+            }
+        }
+    }
+
+    async dynamicRequire(module) {
+        if (typeof require !== 'undefined') {
+            return require(module);
+        }
+        throw new Error(`Module ${module} not available`);
+    }
+
+    async loadModule(wasmPath, options = {}) {
+        await this.ensureNodeModules();
+        
+        const moduleId = options.name || (
+            this.isNode && this.path 
+                ? this.path.basename(wasmPath, '.wasm') 
+                : wasmPath.split('/').pop().replace('.wasm', '')
+        );
+
+        if (this.modules.has(moduleId)) {
+            return this.modules.get(moduleId);
+        }
+
+        try {
+            // Charger wasm_exec.js si nécessaire
+            if (!globalThis.Go) {
+                await this.loadGoRuntime(options.goRuntimePath);
+            }
+
+            const go = new globalThis.Go();
+            let wasmBytes;
+
+            if (this.isNode && this.fs) {
+                if (!this.fs.existsSync(wasmPath)) {
+                    throw new Error(`WASM file not found: ${wasmPath}`);
+                }
+                wasmBytes = this.fs.readFileSync(wasmPath);
+            } else {
+                const response = await fetch(wasmPath);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch WASM file: ${response.status} ${response.statusText}`);
+                }
+                wasmBytes = await response.arrayBuffer();
+            }
+
+            const result = await WebAssembly.instantiate(wasmBytes, go.importObject);
+
+            // Pré-initialisation pour optimiser les performances
+            if (options.preInit !== false) {
+                // Démarrer Go en arrière-plan pour éviter le blocage
+                go.run(result.instance);
+
+                // Attendre que le module soit prêt
+                await this.waitForReady(moduleId);
+            }
+
+            const module = {
+                instance: result.instance,
+                go: go,
+                exports: result.instance.exports,
+                ready: true
+            };
+
+            this.modules.set(moduleId, module);
+            return module;
+
+        } catch (error) {
+            throw new Error(`Failed to load WASM module ${moduleId}: ${error.message}`);
+        }
+    }
+
+    async waitForReady(moduleId, timeout = 5000) {
+        const startTime = Date.now();
+
+        return new Promise((resolve, reject) => {
+            const checkReady = () => {
+                // Vérifier plusieurs signaux de prêt
+                const isReady = globalThis.__gowm_ready ||
+                    (globalThis.Go && globalThis.Go._initialized) ||
+                    (globalThis.add && typeof globalThis.add === 'function');
+
+                if (isReady || Date.now() - startTime > timeout) {
+                    if (isReady) {
+                        resolve();
+                    } else {
+                        reject(new Error(`Module ${moduleId} failed to initialize within ${timeout}ms`));
+                    }
+                } else {
+                    setTimeout(checkReady, 10);
+                }
+            };
+            checkReady();
+        });
+    }
+
+    async loadGoRuntime(customPath) {
+        await this.ensureNodeModules();
+        
+        const runtimePath = customPath || this.getDefaultRuntimePath();
+
+        if (this.isNode && this.fs) {
+            // Vérifier que le fichier existe
+            if (!this.fs.existsSync(runtimePath)) {
+                console.warn(`Go runtime not found at ${runtimePath}, using fallback`);
+                // Utiliser le fallback du dossier runtime
+                const fallbackPath = this.path ? this.path.join(__dirname, '../runtime/wasm_exec.js') : null;
+                if (fallbackPath && this.fs.existsSync(fallbackPath)) {
+                    require(fallbackPath);
+                } else {
+                    throw new Error(`Go runtime not found. Please ensure wasm_exec.js is available`);
+                }
+            } else {
+                require(runtimePath);
+            }
+        } else {
+            await this.loadScript(runtimePath);
+        }
+    }
+
+    getDefaultRuntimePath() {
+        if (this.isNode && this.path) {
+            return this.path.join(__dirname, '../runtime/wasm_exec.js');
+        }
+        return '/wasm_exec.js';
+    }
+
+    loadScript(src) {
+        return new Promise((resolve, reject) => {
+            if (typeof document === 'undefined') {
+                reject(new Error('Cannot load script in non-browser environment'));
+                return;
+            }
+            
+            const script = document.createElement('script');
+            script.src = src;
+            script.onload = resolve;
+            script.onerror = reject;
+            document.head.appendChild(script);
+        });
+    }
+
+    getModule(name) {
+        return this.modules.get(name);
+    }
+
+    unloadModule(name) {
+        const module = this.modules.get(name);
+        if (module && module.go) {
+            // Nettoyage des ressources Go
+            try {
+                module.go.exit(0);
+            } catch (e) {
+                // Ignorer les erreurs de nettoyage
+            }
+        }
+        return this.modules.delete(name);
+    }
+
+    listModules() {
+        return Array.from(this.modules.keys());
+    }
+}
+
+module.exports = WasmLoader;

package/src/loader.js

@@ -1,14 +1,25 @@
-const fs = require('fs');
-const path = require('path');
-
 class WasmLoader {
     constructor() {
         this.modules = new Map();
         this.isNode = typeof window === 'undefined';
+        
+        // Les modules Node.js seront importés de façon dynamique quand nécessaire
+        this.fs = null;
+        this.path = null;
+    }
+
+    async ensureNodeModules() {
+        if (this.isNode && !this.fs) {
+            this.fs = require('fs');
+            this.path = require('path');
+        }
     }
 
     async loadModule(wasmPath, options = {}) {
-        const moduleId = options.name || path.basename(wasmPath, '.wasm');
+        // S'assurer que les modules Node.js sont chargés si nécessaire
+        await this.ensureNodeModules();
+        
+        const moduleId = options.name || (this.isNode ? this.path.basename(wasmPath, '.wasm') : wasmPath.split('/').pop().replace('.wasm', ''));
 
         if (this.modules.has(moduleId)) {
             return this.modules.get(moduleId);
@@ -24,10 +35,10 @@ class WasmLoader {
             let wasmBytes;
 
             if (this.isNode) {
-                if (!fs.existsSync(wasmPath)) {
+                if (!this.fs.existsSync(wasmPath)) {
                     throw new Error(`WASM file not found: ${wasmPath}`);
                 }
-                wasmBytes = fs.readFileSync(wasmPath);
+                wasmBytes = this.fs.readFileSync(wasmPath);
             } else {
                 const response = await fetch(wasmPath);
                 if (!response.ok) {
@@ -87,15 +98,17 @@ class WasmLoader {
     }
 
     async loadGoRuntime(customPath) {
+        await this.ensureNodeModules();
+        
         const runtimePath = customPath || this.getDefaultRuntimePath();
 
         if (this.isNode) {
             // Vérifier que le fichier existe
-            if (!fs.existsSync(runtimePath)) {
+            if (!this.fs.existsSync(runtimePath)) {
                 console.warn(`Go runtime not found at ${runtimePath}, using fallback`);
                 // Utiliser le fallback du dossier runtime
-                const fallbackPath = path.join(__dirname, '../runtime/wasm_exec.js');
-                if (fs.existsSync(fallbackPath)) {
+                const fallbackPath = this.path.join(__dirname, '../runtime/wasm_exec.js');
+                if (this.fs.existsSync(fallbackPath)) {
                     require(fallbackPath);
                 } else {
                     throw new Error(`Go runtime not found. Please ensure wasm_exec.js is available`);
@@ -109,8 +122,8 @@ class WasmLoader {
     }
 
     getDefaultRuntimePath() {
-        if (this.isNode) {
-            return path.join(__dirname, '../runtime/wasm_exec.js');
+        if (this.isNode && this.path) {
+            return this.path.join(__dirname, '../runtime/wasm_exec.js');
         }
         return '/wasm_exec.js';
     }