canvasframework 0.3.6

package/utils/SecureStorage.js

@@ -0,0 +1,289 @@
+/**
+ * Système de stockage sécurisé avec chiffrement AES-GCM
+ * @class
+ * @example
+ * const storage = new SecureStorage('myapp_');
+ * await storage.init('password123');
+ * await storage.setSecure('token', 'secret-token');
+ * const token = await storage.getSecure('token');
+ */
+class SecureStorage {
+  /**
+   * @constructs SecureStorage
+   * @param {string} [prefix='app_'] - Préfixe pour les clés localStorage
+   */
+  constructor(prefix = 'app_') {
+    /** @type {string} */
+    this.prefix = prefix;
+    /** @type {CryptoKey|null} */
+    this.encryptionKey = null;
+    /** @type {Map<string, any>} */
+    this.memoryCache = new Map();
+  }
+
+  /**
+   * Initialiser avec une clé de chiffrement
+   * @param {string} password - Mot de passe pour générer la clé de chiffrement
+   * @returns {Promise<boolean>} True si l'initialisation a réussi
+   */
+  async init(password) {
+    try {
+      // Générer une clé de chiffrement à partir du password
+      const encoder = new TextEncoder();
+      const data = encoder.encode(password);
+      const hash = await crypto.subtle.digest('SHA-256', data);
+      
+      this.encryptionKey = await crypto.subtle.importKey(
+        'raw',
+        hash,
+        { name: 'AES-GCM' },
+        false,
+        ['encrypt', 'decrypt']
+      );
+      
+      return true;
+    } catch (error) {
+      console.error('Failed to initialize SecureStorage:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Chiffrer des données
+   * @param {*} data - Données à chiffrer
+   * @returns {Promise<string>} Données chiffrées en base64
+   * @throws {Error} Si SecureStorage n'est pas initialisé
+   * @private
+   */
+  async encrypt(data) {
+    if (!this.encryptionKey) {
+      throw new Error('SecureStorage not initialized. Call init() first.');
+    }
+
+    try {
+      const encoder = new TextEncoder();
+      const dataBuffer = encoder.encode(JSON.stringify(data));
+      
+      // Générer un IV aléatoire
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      
+      // Chiffrer
+      const encrypted = await crypto.subtle.encrypt(
+        { name: 'AES-GCM', iv },
+        this.encryptionKey,
+        dataBuffer
+      );
+      
+      // Combiner IV et données chiffrées
+      const combined = new Uint8Array(iv.length + encrypted.byteLength);
+      combined.set(iv);
+      combined.set(new Uint8Array(encrypted), iv.length);
+      
+      // Convertir en base64
+      return btoa(String.fromCharCode(...combined));
+    } catch (error) {
+      console.error('Encryption failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Déchiffrer des données
+   * @param {string} encryptedData - Données chiffrées en base64
+   * @returns {Promise<*>} Données déchiffrées
+   * @throws {Error} Si SecureStorage n'est pas initialisé
+   * @private
+   */
+  async decrypt(encryptedData) {
+    if (!this.encryptionKey) {
+      throw new Error('SecureStorage not initialized. Call init() first.');
+    }
+
+    try {
+      // Décoder base64
+      const combined = new Uint8Array(
+        atob(encryptedData).split('').map(char => char.charCodeAt(0))
+      );
+      
+      // Extraire IV et données
+      const iv = combined.slice(0, 12);
+      const data = combined.slice(12);
+      
+      // Déchiffrer
+      const decrypted = await crypto.subtle.decrypt(
+        { name: 'AES-GCM', iv },
+        this.encryptionKey,
+        data
+      );
+      
+      // Décoder et parser
+      const decoder = new TextDecoder();
+      return JSON.parse(decoder.decode(decrypted));
+    } catch (error) {
+      console.error('Decryption failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Sauvegarder une valeur de manière sécurisée (chiffrée)
+   * @param {string} key - Clé de stockage
+   * @param {*} value - Valeur à sauvegarder
+   * @returns {Promise<boolean>} True si la sauvegarde a réussi
+   */
+  async setSecure(key, value) {
+    try {
+      const encrypted = await this.encrypt(value);
+      localStorage.setItem(this.prefix + key, encrypted);
+      this.memoryCache.set(key, value);
+      return true;
+    } catch (error) {
+      console.error('Failed to save secure data:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Récupérer une valeur de manière sécurisée (déchiffrée)
+   * @param {string} key - Clé de stockage
+   * @param {*} [defaultValue=null] - Valeur par défaut si la clé n'existe pas
+   * @returns {Promise<*>} Valeur déchiffrée ou valeur par défaut
+   */
+  async getSecure(key, defaultValue = null) {
+    try {
+      // Vérifier le cache mémoire
+      if (this.memoryCache.has(key)) {
+        return this.memoryCache.get(key);
+      }
+      
+      const encrypted = localStorage.getItem(this.prefix + key);
+      if (!encrypted) {
+        return defaultValue;
+      }
+      
+      const value = await this.decrypt(encrypted);
+      this.memoryCache.set(key, value);
+      return value;
+    } catch (error) {
+      console.error('Failed to get secure data:', error);
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Sauvegarder une valeur en clair (pour données non sensibles)
+   * @param {string} key - Clé de stockage
+   * @param {*} value - Valeur à sauvegarder
+   * @returns {boolean} True si la sauvegarde a réussi
+   */
+  set(key, value) {
+    try {
+      localStorage.setItem(this.prefix + key, JSON.stringify(value));
+      return true;
+    } catch (error) {
+      console.error('Failed to save data:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Récupérer une valeur en clair
+   * @param {string} key - Clé de stockage
+   * @param {*} [defaultValue=null] - Valeur par défaut si la clé n'existe pas
+   * @returns {*} Valeur ou valeur par défaut
+   */
+  get(key, defaultValue = null) {
+    try {
+      const item = localStorage.getItem(this.prefix + key);
+      return item ? JSON.parse(item) : defaultValue;
+    } catch (error) {
+      console.error('Failed to get data:', error);
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Supprimer une clé
+   * @param {string} key - Clé à supprimer
+   */
+  remove(key) {
+    localStorage.removeItem(this.prefix + key);
+    this.memoryCache.delete(key);
+  }
+
+  /**
+   * Vérifier si une clé existe
+   * @param {string} key - Clé à vérifier
+   * @returns {boolean} True si la clé existe
+   */
+  has(key) {
+    return localStorage.getItem(this.prefix + key) !== null;
+  }
+
+  /**
+   * Vider le cache mémoire
+   */
+  clearCache() {
+    this.memoryCache.clear();
+  }
+
+  /**
+   * Tout supprimer (données avec le préfixe)
+   */
+  clear() {
+    const keys = Object.keys(localStorage);
+    keys.forEach(key => {
+      if (key.startsWith(this.prefix)) {
+        localStorage.removeItem(key);
+      }
+    });
+    this.clearCache();
+  }
+
+  /**
+   * Obtenir toutes les clés
+   * @returns {string[]} Liste des clés (sans le préfixe)
+   */
+  keys() {
+    return Object.keys(localStorage)
+      .filter(key => key.startsWith(this.prefix))
+      .map(key => key.substring(this.prefix.length));
+  }
+
+  /**
+   * Exporter toutes les données de manière sécurisée
+   * @returns {Promise<string>} Données chiffrées contenant toutes les clés/valeurs
+   */
+  async exportSecure() {
+    const data = {};
+    const keys = this.keys();
+    
+    for (const key of keys) {
+      data[key] = await this.getSecure(key);
+    }
+    
+    return await this.encrypt(data);
+  }
+
+  /**
+   * Importer des données de manière sécurisée
+   * @param {string} encryptedData - Données chiffrées exportées
+   * @returns {Promise<boolean>} True si l'import a réussi
+   */
+  async importSecure(encryptedData) {
+    try {
+      const data = await this.decrypt(encryptedData);
+      
+      for (const [key, value] of Object.entries(data)) {
+        await this.setSecure(key, value);
+      }
+      
+      return true;
+    } catch (error) {
+      console.error('Failed to import data:', error);
+      return false;
+    }
+  }
+}
+
+export default SecureStorage;

package/utils/StateManager.js

@@ -0,0 +1,207 @@
+/**
+ * Système de gestion d'état avec historique (undo/redo) et observateurs
+ * @class
+ * @example
+ * const state = new StateManager();
+ * state.set('user.name', 'John');
+ * const unsubscribe = state.subscribe('user.name', (newValue, oldValue) => {
+ *   console.log('Name changed:', oldValue, '->', newValue);
+ * });
+ */
+class StateManager {
+  /**
+   * @constructs StateManager
+   */
+  constructor() {
+    /** @type {Object} */
+    this.state = {};
+    /** @type {Map<string, Function[]>} */
+    this.listeners = new Map();
+    /** @type {Array<Object>} */
+    this.history = [];
+    /** @type {number} */
+    this.historyIndex = -1;
+    /** @type {number} */
+    this.maxHistory = 50;
+  }
+
+  /**
+   * Définir une valeur dans le state
+   * @param {string} key - Clé à définir
+   * @param {*} value - Valeur à assigner
+   * @param {boolean} [saveToHistory=true] - Sauvegarder dans l'historique
+   */
+  set(key, value, saveToHistory = true) {
+    const oldValue = this.state[key];
+    
+    if (saveToHistory && oldValue !== value) {
+      this.addToHistory(key, oldValue, value);
+    }
+    
+    this.state[key] = value;
+    this.notify(key, value, oldValue);
+  }
+
+  /**
+   * Récupérer une valeur du state
+   * @param {string} key - Clé à récupérer
+   * @param {*} [defaultValue=null] - Valeur par défaut si la clé n'existe pas
+   * @returns {*} La valeur de la clé ou la valeur par défaut
+   */
+  get(key, defaultValue = null) {
+    return this.state.hasOwnProperty(key) ? this.state[key] : defaultValue;
+  }
+
+  /**
+   * Mettre à jour plusieurs valeurs à la fois
+   * @param {Object} updates - Objet avec les clés/valeurs à mettre à jour
+   * @param {boolean} [saveToHistory=true] - Sauvegarder dans l'historique
+   */
+  update(updates, saveToHistory = true) {
+    Object.keys(updates).forEach(key => {
+      this.set(key, updates[key], saveToHistory);
+    });
+  }
+
+  /**
+   * Supprimer une clé du state
+   * @param {string} key - Clé à supprimer
+   */
+  delete(key) {
+    const oldValue = this.state[key];
+    delete this.state[key];
+    this.notify(key, undefined, oldValue);
+  }
+
+  /**
+   * S'abonner aux changements d'une clé
+   * @param {string} key - Clé à observer (ou '*' pour toutes les clés)
+   * @param {Function} callback - Fonction appelée lors des changements
+   * @returns {Function} Fonction de désabonnement
+   */
+  subscribe(key, callback) {
+    if (!this.listeners.has(key)) {
+      this.listeners.set(key, []);
+    }
+    this.listeners.get(key).push(callback);
+    
+    // Retourner une fonction de désabonnement
+    return () => {
+      const callbacks = this.listeners.get(key);
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Notifier les observateurs d'un changement
+   * @param {string} key - Clé qui a changé
+   * @param {*} newValue - Nouvelle valeur
+   * @param {*} oldValue - Ancienne valeur
+   * @private
+   */
+  notify(key, newValue, oldValue) {
+    if (this.listeners.has(key)) {
+      this.listeners.get(key).forEach(callback => {
+        callback(newValue, oldValue);
+      });
+    }
+    
+    // Notifier les listeners globaux (*)
+    if (this.listeners.has('*')) {
+      this.listeners.get('*').forEach(callback => {
+        callback(key, newValue, oldValue);
+      });
+    }
+  }
+
+  /**
+   * Ajouter une modification à l'historique
+   * @param {string} key - Clé modifiée
+   * @param {*} oldValue - Ancienne valeur
+   * @param {*} newValue - Nouvelle valeur
+   * @private
+   */
+  addToHistory(key, oldValue, newValue) {
+    // Supprimer l'historique après l'index actuel
+    this.history = this.history.slice(0, this.historyIndex + 1);
+    
+    this.history.push({ key, oldValue, newValue, timestamp: Date.now() });
+    
+    // Limiter la taille de l'historique
+    if (this.history.length > this.maxHistory) {
+      this.history.shift();
+    } else {
+      this.historyIndex++;
+    }
+  }
+
+  /**
+   * Annuler la dernière modification
+   * @returns {boolean} True si une opération a été annulée
+   */
+  undo() {
+    if (this.historyIndex >= 0) {
+      const { key, oldValue } = this.history[this.historyIndex];
+      this.set(key, oldValue, false);
+      this.historyIndex--;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Rétablir la dernière modification annulée
+   * @returns {boolean} True si une opération a été rétablie
+   */
+  redo() {
+    if (this.historyIndex < this.history.length - 1) {
+      this.historyIndex++;
+      const { key, newValue } = this.history[this.historyIndex];
+      this.set(key, newValue, false);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Réinitialiser complètement le state
+   */
+  reset() {
+    const keys = Object.keys(this.state);
+    this.state = {};
+    keys.forEach(key => this.notify(key, undefined));
+    this.history = [];
+    this.historyIndex = -1;
+  }
+
+  /**
+   * Exporter le state en JSON
+   * @returns {string} Le state sérialisé en JSON
+   */
+  export() {
+    return JSON.stringify(this.state);
+  }
+
+  /**
+   * Importer un state depuis du JSON
+   * @param {string} jsonState - State sérialisé en JSON
+   * @returns {boolean} True si l'import a réussi
+   */
+  import(jsonState) {
+    try {
+      const newState = JSON.parse(jsonState);
+      Object.keys(newState).forEach(key => {
+        this.set(key, newState[key], false);
+      });
+      return true;
+    } catch (error) {
+      console.error('Error importing state:', error);
+      return false;
+    }
+  }
+}
+
+export default StateManager;

package/utils/WebSocketClient.js

@@ -0,0 +1,66 @@
+/**
+ * Client WebSocket avec events et JSON automatique
+ * @class
+ * @property {string} url - URL du serveur WebSocket
+ * @property {WebSocket|null} ws - Instance WebSocket
+ * @property {Object<string, Function[]>} listeners - Listeners par event ('open','message','close','error')
+ */
+class WebSocketClient {
+  /**
+   * Crée une instance de WebSocketClient
+   * @param {string} url - URL du serveur WS
+   */
+  constructor(url) {
+    this.url = url;
+    this.ws = null;
+    this.listeners = { open: [], message: [], close: [], error: [] };
+  }
+
+  /**
+   * Connexion au serveur WebSocket
+   */
+  connect() {
+    this.ws = new WebSocket(this.url);
+
+    this.ws.onopen = (e) => this.listeners.open.forEach(fn => fn(e));
+    this.ws.onmessage = (e) => {
+      try {
+        const data = JSON.parse(e.data);
+        this.listeners.message.forEach(fn => fn(data));
+      } catch {
+        this.listeners.message.forEach(fn => fn(e.data));
+      }
+    };
+    this.ws.onclose = (e) => this.listeners.close.forEach(fn => fn(e));
+    this.ws.onerror = (e) => this.listeners.error.forEach(fn => fn(e));
+  }
+
+  /**
+   * Envoie des données
+   * @param {any} data - Données JSON ou string
+   */
+  send(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket not connected");
+    }
+    this.ws.send(JSON.stringify(data));
+  }
+
+  /**
+   * Écoute un event
+   * @param {'open'|'message'|'close'|'error'} event - Nom de l'event
+   * @param {Function} callback - Callback
+   */
+  on(event, callback) {
+    if (this.listeners[event]) this.listeners[event].push(callback);
+  }
+
+  /**
+   * Déconnecte le WebSocket
+   */
+  disconnect() {
+    if (this.ws) this.ws.close();
+  }
+}
+
+export default WebSocketClient;