canvasframework 0.5.16 → 0.5.18

package/utils/CryptoManager.js

@@ -1,303 +0,0 @@
-/**
- * Gestionnaire de cryptographie pour le Canvas Framework
- * Utilise l'API Web Crypto (SubtleCrypto) pour un chiffrement sécurisé
- * @class
- */
-class CryptoManager {
-  constructor() {
-    // Vérifier la disponibilité de l'API Crypto
-    if (!window.crypto || !window.crypto.subtle) {
-      throw new Error('Web Crypto API is not available in this browser');
-    }
-    
-    this.crypto = window.crypto.subtle;
-    
-    // Algorithme par défaut
-    this.algorithm = {
-      name: 'AES-GCM',
-      length: 256
-    };
-    
-    // Stockage des clés en mémoire (pas dans localStorage !)
-    this._keys = new Map();
-  }
-
-  /**
-   * Génère une clé de chiffrement aléatoire
-   * @param {string} keyName - Nom de la clé pour référence ultérieure
-   * @returns {Promise<CryptoKey>}
-   */
-  async generateKey(keyName = 'default') {
-    const key = await this.crypto.generateKey(
-      {
-        name: this.algorithm.name,
-        length: this.algorithm.length
-      },
-      true, // extractable
-      ['encrypt', 'decrypt']
-    );
-    
-    this._keys.set(keyName, key);
-    return key;
-  }
-
-  /**
-   * Importe une clé depuis une chaîne (base64)
-   * @param {string} keyString - Clé au format base64
-   * @param {string} keyName - Nom de la clé
-   * @returns {Promise<CryptoKey>}
-   */
-  async importKey(keyString, keyName = 'default') {
-    const keyBuffer = this._base64ToBuffer(keyString);
-    
-    const key = await this.crypto.importKey(
-      'raw',
-      keyBuffer,
-      { name: this.algorithm.name },
-      true,
-      ['encrypt', 'decrypt']
-    );
-    
-    this._keys.set(keyName, key);
-    return key;
-  }
-
-  /**
-   * Exporte une clé au format base64
-   * @param {string} keyName - Nom de la clé
-   * @returns {Promise<string>}
-   */
-  async exportKey(keyName = 'default') {
-    const key = this._keys.get(keyName);
-    if (!key) {
-      throw new Error(`Key "${keyName}" not found`);
-    }
-    
-    const exported = await this.crypto.exportKey('raw', key);
-    return this._bufferToBase64(exported);
-  }
-
-  /**
-   * Dérive une clé depuis un mot de passe
-   * @param {string} password - Mot de passe
-   * @param {string} keyName - Nom de la clé
-   * @param {string} salt - Salt (optionnel, généré automatiquement)
-   * @returns {Promise<{key: CryptoKey, salt: string}>}
-   */
-  async deriveKeyFromPassword(password, keyName = 'default', salt = null) {
-    // Générer ou utiliser le salt fourni
-    const saltBuffer = salt 
-      ? this._base64ToBuffer(salt)
-      : window.crypto.getRandomValues(new Uint8Array(16));
-    
-    // Encoder le mot de passe
-    const encoder = new TextEncoder();
-    const passwordBuffer = encoder.encode(password);
-    
-    // Importer le mot de passe comme clé
-    const keyMaterial = await this.crypto.importKey(
-      'raw',
-      passwordBuffer,
-      { name: 'PBKDF2' },
-      false,
-      ['deriveBits', 'deriveKey']
-    );
-    
-    // Dériver la clé
-    const key = await this.crypto.deriveKey(
-      {
-        name: 'PBKDF2',
-        salt: saltBuffer,
-        iterations: 100000,
-        hash: 'SHA-256'
-      },
-      keyMaterial,
-      { name: this.algorithm.name, length: this.algorithm.length },
-      true,
-      ['encrypt', 'decrypt']
-    );
-    
-    this._keys.set(keyName, key);
-    
-    return {
-      key,
-      salt: this._bufferToBase64(saltBuffer)
-    };
-  }
-
-  /**
-   * Chiffre des données
-   * @param {any} data - Données à chiffrer (sera converti en JSON)
-   * @param {string} keyName - Nom de la clé à utiliser
-   * @returns {Promise<{encrypted: string, iv: string}>}
-   */
-  async encrypt(data, keyName = 'default') {
-    const key = this._keys.get(keyName);
-    if (!key) {
-      throw new Error(`Key "${keyName}" not found. Generate or import a key first.`);
-    }
-    
-    // Convertir les données en JSON puis en buffer
-    const dataString = typeof data === 'string' ? data : JSON.stringify(data);
-    const encoder = new TextEncoder();
-    const dataBuffer = encoder.encode(dataString);
-    
-    // Générer un IV (Initialization Vector) aléatoire
-    const iv = window.crypto.getRandomValues(new Uint8Array(12));
-    
-    // Chiffrer
-    const encryptedBuffer = await this.crypto.encrypt(
-      {
-        name: this.algorithm.name,
-        iv: iv
-      },
-      key,
-      dataBuffer
-    );
-    
-    return {
-      encrypted: this._bufferToBase64(encryptedBuffer),
-      iv: this._bufferToBase64(iv)
-    };
-  }
-
-  /**
-   * Déchiffre des données
-   * @param {string} encryptedData - Données chiffrées (base64)
-   * @param {string} iv - IV utilisé lors du chiffrement (base64)
-   * @param {string} keyName - Nom de la clé à utiliser
-   * @param {boolean} parseJson - Parser le résultat en JSON (true par défaut)
-   * @returns {Promise<any>}
-   */
-  async decrypt(encryptedData, iv, keyName = 'default', parseJson = true) {
-    const key = this._keys.get(keyName);
-    if (!key) {
-      throw new Error(`Key "${keyName}" not found. Generate or import a key first.`);
-    }
-    
-    // Convertir les chaînes base64 en buffers
-    const encryptedBuffer = this._base64ToBuffer(encryptedData);
-    const ivBuffer = this._base64ToBuffer(iv);
-    
-    // Déchiffrer
-    const decryptedBuffer = await this.crypto.decrypt(
-      {
-        name: this.algorithm.name,
-        iv: ivBuffer
-      },
-      key,
-      encryptedBuffer
-    );
-    
-    // Convertir le buffer en string
-    const decoder = new TextDecoder();
-    const decryptedString = decoder.decode(decryptedBuffer);
-    
-    // Parser en JSON si demandé
-    if (parseJson) {
-      try {
-        return JSON.parse(decryptedString);
-      } catch (e) {
-        // Si le parsing échoue, retourner la chaîne brute
-        return decryptedString;
-      }
-    }
-    
-    return decryptedString;
-  }
-
-  /**
-   * Chiffre et encode en une seule chaîne (pratique pour stockage)
-   * @param {any} data - Données à chiffrer
-   * @param {string} keyName - Nom de la clé
-   * @returns {Promise<string>} - Chaîne contenant données chiffrées + IV
-   */
-  async encryptToString(data, keyName = 'default') {
-    const { encrypted, iv } = await this.encrypt(data, keyName);
-    return `${encrypted}.${iv}`;
-  }
-
-  /**
-   * Déchiffre depuis une chaîne créée par encryptToString
-   * @param {string} encryptedString - Chaîne chiffrée
-   * @param {string} keyName - Nom de la clé
-   * @param {boolean} parseJson - Parser en JSON
-   * @returns {Promise<any>}
-   */
-  async decryptFromString(encryptedString, keyName = 'default', parseJson = true) {
-    const [encrypted, iv] = encryptedString.split('.');
-    if (!encrypted || !iv) {
-      throw new Error('Invalid encrypted string format');
-    }
-    return this.decrypt(encrypted, iv, keyName, parseJson);
-  }
-
-  /**
-   * Hash une chaîne (non réversible)
-   * @param {string} data - Données à hasher
-   * @param {string} algorithm - Algorithme (SHA-256, SHA-384, SHA-512)
-   * @returns {Promise<string>} - Hash en base64
-   */
-  async hash(data, algorithm = 'SHA-256') {
-    const encoder = new TextEncoder();
-    const dataBuffer = encoder.encode(data);
-    
-    const hashBuffer = await this.crypto.digest(algorithm, dataBuffer);
-    return this._bufferToBase64(hashBuffer);
-  }
-
-  /**
-   * Génère un token aléatoire sécurisé
-   * @param {number} length - Longueur en octets (32 par défaut)
-   * @returns {string} - Token en base64
-   */
-  generateToken(length = 32) {
-    const buffer = window.crypto.getRandomValues(new Uint8Array(length));
-    return this._bufferToBase64(buffer);
-  }
-
-  /**
-   * Supprime une clé de la mémoire
-   * @param {string} keyName - Nom de la clé
-   */
-  deleteKey(keyName) {
-    this._keys.delete(keyName);
-  }
-
-  /**
-   * Supprime toutes les clés
-   */
-  deleteAllKeys() {
-    this._keys.clear();
-  }
-
-  /**
-   * Liste les clés disponibles
-   * @returns {string[]}
-   */
-  listKeys() {
-    return Array.from(this._keys.keys());
-  }
-
-  // ===== Méthodes utilitaires =====
-
-  _bufferToBase64(buffer) {
-    const bytes = new Uint8Array(buffer);
-    let binary = '';
-    for (let i = 0; i < bytes.length; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-
-  _base64ToBuffer(base64) {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes.buffer;
-  }
-}
-
-export default CryptoManager;

package/utils/DataStore.js

@@ -1,403 +0,0 @@
-/**
- * Cache local avec TTL (Time To Live) et gestion avancée
- * @class
- * @property {Map} store - Stockage interne
- * @property {number} defaultTTL - TTL par défaut en ms
- * @property {number} maxSize - Taille max du cache
- * @property {Object} stats - Statistiques du cache
- */
-class DataStore {
-  /**
-   * Crée une instance de DataStore
-   * @param {Object} [options={}] - Options
-   * @param {number} [options.defaultTTL=3600000] - TTL par défaut (1h)
-   * @param {number} [options.maxSize=100] - Taille max du cache
-   * @param {boolean} [options.enableStats=true] - Activer les stats
-   */
-  constructor(options = {}) {
-    this.store = new Map();
-    this.defaultTTL = options.defaultTTL || 3600000; // 1 heure par défaut
-    this.maxSize = options.maxSize || 100;
-    this.enableStats = options.enableStats !== false;
-    
-    // Statistiques
-    this.stats = {
-      hits: 0,
-      misses: 0,
-      sets: 0,
-      deletes: 0,
-      evictions: 0
-    };
-    
-    // Nettoyage périodique
-    this.startCleanupInterval();
-  }
-
-  /**
-   * Stocke une valeur avec TTL
-   * @param {string} key - Clé
-   * @param {*} value - Valeur
-   * @param {number} [ttl] - TTL en ms (optionnel)
-   * @returns {DataStore} Instance pour chaînage
-   */
-  set(key, value, ttl) {
-    const expiresAt = Date.now() + (ttl || this.defaultTTL);
-    
-    // Si le cache est plein, supprimer l'élément le plus ancien
-    if (this.store.size >= this.maxSize && !this.store.has(key)) {
-      this.evictOldest();
-    }
-    
-    this.store.set(key, {
-      value,
-      expiresAt,
-      createdAt: Date.now(),
-      accessCount: 0
-    });
-    
-    if (this.enableStats) this.stats.sets++;
-    
-    return this;
-  }
-
-  /**
-   * Récupère une valeur
-   * @param {string} key - Clé
-   * @param {*} [defaultValue=null] - Valeur par défaut
-   * @returns {*} Valeur ou null
-   */
-  get(key, defaultValue = null) {
-    const item = this.store.get(key);
-    
-    if (!item) {
-      if (this.enableStats) this.stats.misses++;
-      return defaultValue;
-    }
-    
-    // Vérifier l'expiration
-    if (Date.now() > item.expiresAt) {
-      this.delete(key);
-      if (this.enableStats) this.stats.misses++;
-      return defaultValue;
-    }
-    
-    // Mettre à jour les stats d'accès
-    item.accessCount++;
-    
-    if (this.enableStats) this.stats.hits++;
-    
-    return item.value;
-  }
-
-  /**
-   * Vérifie si une clé existe et n'est pas expirée
-   * @param {string} key - Clé
-   * @returns {boolean} True si existe et valide
-   */
-  has(key) {
-    const item = this.store.get(key);
-    
-    if (!item) return false;
-    
-    if (Date.now() > item.expiresAt) {
-      this.delete(key);
-      return false;
-    }
-    
-    return true;
-  }
-
-  /**
-   * Supprime une entrée
-   * @param {string} key - Clé
-   * @returns {boolean} True si supprimé
-   */
-  delete(key) {
-    const deleted = this.store.delete(key);
-    if (deleted && this.enableStats) this.stats.deletes++;
-    return deleted;
-  }
-
-  /**
-   * Vide tout le cache
-   */
-  clear() {
-    this.store.clear();
-    if (this.enableStats) {
-      this.stats = {
-        hits: 0,
-        misses: 0,
-        sets: 0,
-        deletes: 0,
-        evictions: 0
-      };
-    }
-  }
-
-  /**
-   * Récupère ou calcule une valeur (memoization)
-   * @param {string} key - Clé
-   * @param {Function} factory - Fonction qui retourne la valeur
-   * @param {number} [ttl] - TTL optionnel
-   * @returns {Promise<*>} Valeur
-   */
-  async getOrSet(key, factory, ttl) {
-    if (this.has(key)) {
-      return this.get(key);
-    }
-    
-    const value = await factory();
-    this.set(key, value, ttl);
-    return value;
-  }
-
-  /**
-   * Récupère plusieurs valeurs
-   * @param {Array<string>} keys - Clés
-   * @returns {Object} Objet clé-valeur
-   */
-  getMany(keys) {
-    const result = {};
-    
-    for (let key of keys) {
-      const value = this.get(key);
-      if (value !== null) {
-        result[key] = value;
-      }
-    }
-    
-    return result;
-  }
-
-  /**
-   * Stocke plusieurs valeurs
-   * @param {Object} items - Objet clé-valeur
-   * @param {number} [ttl] - TTL optionnel
-   * @returns {DataStore} Instance pour chaînage
-   */
-  setMany(items, ttl) {
-    for (let key in items) {
-      this.set(key, items[key], ttl);
-    }
-    return this;
-  }
-
-  /**
-   * Supprime plusieurs entrées
-   * @param {Array<string>} keys - Clés
-   * @returns {number} Nombre de suppressions
-   */
-  deleteMany(keys) {
-    let count = 0;
-    for (let key of keys) {
-      if (this.delete(key)) count++;
-    }
-    return count;
-  }
-
-  /**
-   * Met à jour le TTL d'une entrée
-   * @param {string} key - Clé
-   * @param {number} ttl - Nouveau TTL en ms
-   * @returns {boolean} True si mis à jour
-   */
-  touch(key, ttl) {
-    const item = this.store.get(key);
-    
-    if (!item) return false;
-    
-    item.expiresAt = Date.now() + (ttl || this.defaultTTL);
-    return true;
-  }
-
-  /**
-   * Obtient le TTL restant
-   * @param {string} key - Clé
-   * @returns {number} TTL en ms, ou -1 si n'existe pas
-   */
-  ttl(key) {
-    const item = this.store.get(key);
-    
-    if (!item) return -1;
-    
-    const remaining = item.expiresAt - Date.now();
-    return remaining > 0 ? remaining : -1;
-  }
-
-  /**
-   * Évince l'élément le plus ancien (LRU)
-   * @private
-   */
-  evictOldest() {
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    
-    for (let [key, item] of this.store.entries()) {
-      // Utiliser l'accès le moins récent comme critère
-      const priority = item.createdAt - (item.accessCount * 1000);
-      
-      if (priority < oldestTime) {
-        oldestTime = priority;
-        oldestKey = key;
-      }
-    }
-    
-    if (oldestKey) {
-      this.store.delete(oldestKey);
-      if (this.enableStats) this.stats.evictions++;
-    }
-  }
-
-  /**
-   * Nettoie les entrées expirées
-   * @returns {number} Nombre d'entrées nettoyées
-   */
-  cleanup() {
-    const now = Date.now();
-    let cleaned = 0;
-    
-    for (let [key, item] of this.store.entries()) {
-      if (now > item.expiresAt) {
-        this.store.delete(key);
-        cleaned++;
-      }
-    }
-    
-    return cleaned;
-  }
-
-  /**
-   * Démarre le nettoyage automatique
-   * @param {number} [interval=60000] - Intervalle en ms (1 minute)
-   * @private
-   */
-  startCleanupInterval(interval = 60000) {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-    }
-    
-    this.cleanupTimer = setInterval(() => {
-      this.cleanup();
-    }, interval);
-  }
-
-  /**
-   * Arrête le nettoyage automatique
-   */
-  stopCleanupInterval() {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-  }
-
-  /**
-   * Obtient toutes les clés
-   * @param {boolean} [includeExpired=false] - Inclure les expirées
-   * @returns {Array<string>} Liste des clés
-   */
-  keys(includeExpired = false) {
-    const keys = [];
-    const now = Date.now();
-    
-    for (let [key, item] of this.store.entries()) {
-      if (includeExpired || now <= item.expiresAt) {
-        keys.push(key);
-      }
-    }
-    
-    return keys;
-  }
-
-  /**
-   * Obtient la taille du cache
-   * @returns {number} Nombre d'entrées
-   */
-  size() {
-    return this.store.size;
-  }
-
-  /**
-   * Obtient les statistiques
-   * @returns {Object} Statistiques
-   */
-  getStats() {
-    const hitRate = this.stats.hits + this.stats.misses > 0 
-      ? (this.stats.hits / (this.stats.hits + this.stats.misses) * 100).toFixed(2)
-      : 0;
-    
-    return {
-      ...this.stats,
-      size: this.store.size,
-      hitRate: `${hitRate}%`,
-      maxSize: this.maxSize
-    };
-  }
-
-  /**
-   * Réinitialise les statistiques
-   */
-  resetStats() {
-    this.stats = {
-      hits: 0,
-      misses: 0,
-      sets: 0,
-      deletes: 0,
-      evictions: 0
-    };
-  }
-
-  /**
-   * Exporte le cache en JSON
-   * @returns {string} JSON
-   */
-  export() {
-    const data = {};
-    
-    for (let [key, item] of this.store.entries()) {
-      data[key] = {
-        value: item.value,
-        expiresAt: item.expiresAt,
-        createdAt: item.createdAt
-      };
-    }
-    
-    return JSON.stringify(data);
-  }
-
-  /**
-   * Importe un cache depuis JSON
-   * @param {string} json - JSON
-   */
-  import(json) {
-    const data = JSON.parse(json);
-    const now = Date.now();
-    
-    for (let key in data) {
-      const item = data[key];
-      
-      // Ne pas importer les entrées expirées
-      if (item.expiresAt > now) {
-        this.store.set(key, {
-          value: item.value,
-          expiresAt: item.expiresAt,
-          createdAt: item.createdAt,
-          accessCount: 0
-        });
-      }
-    }
-  }
-
-  /**
-   * Détruit le store
-   */
-  destroy() {
-    this.stopCleanupInterval();
-    this.clear();
-  }
-}
-
-// Instance globale par défaut
-DataStore.global = new DataStore();
-
-export default DataStore;