@bantis/local-cipher 2.0.1 → 2.2.0

package/dist/index.esm.js

@@ -1,8 +1,3 @@
-import { useState, useEffect, useCallback } from 'react';
-import { Injectable } from '@angular/core';
-import { BehaviorSubject, Subject, from } from 'rxjs';
-import { map, catchError } from 'rxjs/operators';
-
 /**
  * Configuration types for @bantis/local-cipher
  */
@@ -111,7 +106,7 @@ class EncryptionHelper {
         // Derivar la clave AES-GCM
         return crypto.subtle.deriveKey({
             name: 'PBKDF2',
-            salt,
+            salt: salt,
             iterations: this.config.iterations,
             hash: EncryptionHelper.HASH_ALGORITHM,
         }, keyMaterial, {
@@ -393,7 +388,7 @@ class Logger {
             return false;
         return Logger.LOG_LEVELS[level] <= Logger.LOG_LEVELS[this.logLevel];
     }
-    formatMessage(level, message, ...args) {
+    formatMessage(level, message) {
         const timestamp = new Date().toISOString();
         return `[${this.prefix}] [${level.toUpperCase()}] ${timestamp} - ${message}`;
     }
@@ -546,17 +541,37 @@ class NamespacedStorage {
         this.storage = storage;
         this.prefix = `__ns_${namespace}__`;
     }
+    async getIndex() {
+        const indexValue = await this.storage.getItem(`${this.prefix}__index__`);
+        return indexValue ? JSON.parse(indexValue) : [];
+    }
+    async saveToIndex(key) {
+        const index = await this.getIndex();
+        if (!index.includes(key)) {
+            index.push(key);
+            await this.storage.setItem(`${this.prefix}__index__`, JSON.stringify(index));
+        }
+    }
+    async removeFromIndex(key) {
+        const index = await this.getIndex();
+        const newIndex = index.filter(k => k !== key);
+        if (newIndex.length !== index.length) {
+            await this.storage.setItem(`${this.prefix}__index__`, JSON.stringify(newIndex));
+        }
+    }
     /**
      * Set item in this namespace
      */
     async setItem(key, value) {
-        return this.storage.setItem(`${this.prefix}${key}`, value);
+        await this.storage.setItem(`${this.prefix}${key}`, value);
+        await this.saveToIndex(key);
     }
     /**
      * Set item with expiry in this namespace
      */
     async setItemWithExpiry(key, value, options) {
-        return this.storage.setItemWithExpiry(`${this.prefix}${key}`, value, options);
+        await this.storage.setItemWithExpiry(`${this.prefix}${key}`, value, options);
+        await this.saveToIndex(key);
     }
     /**
      * Get item from this namespace
@@ -568,7 +583,8 @@ class NamespacedStorage {
      * Remove item from this namespace
      */
     async removeItem(key) {
-        return this.storage.removeItem(`${this.prefix}${key}`);
+        await this.storage.removeItem(`${this.prefix}${key}`);
+        await this.removeFromIndex(key);
     }
     /**
      * Check if item exists in this namespace
@@ -580,29 +596,17 @@ class NamespacedStorage {
      * Clear all items in this namespace
      */
     async clearNamespace() {
-        const keysToRemove = [];
-        for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key && key.includes(this.prefix)) {
-                keysToRemove.push(key.replace(this.prefix, ''));
-            }
-        }
+        const keysToRemove = await this.getIndex();
         for (const key of keysToRemove) {
-            await this.removeItem(key);
+            await this.storage.removeItem(`${this.prefix}${key}`);
         }
+        await this.storage.removeItem(`${this.prefix}__index__`);
     }
     /**
      * Get all keys in this namespace
      */
     async keys() {
-        const keys = [];
-        for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key && key.includes(this.prefix)) {
-                keys.push(key.replace(this.prefix, ''));
-            }
-        }
-        return keys;
+        return this.getIndex();
     }
 }
 
@@ -625,7 +629,6 @@ async function compress(data) {
         return encoder.encode(data);
     }
     try {
-        const encoder = new TextEncoder();
         const stream = new Blob([data]).stream();
         const compressedStream = stream.pipeThrough(new CompressionStream('gzip'));
         const compressedBlob = await new Response(compressedStream).blob();
@@ -1154,11 +1157,12 @@ class SecureStorage {
         }
         this.removeAllListeners();
         this.logger.info('SecureStorage destroyed');
+        SecureStorage.instance = null;
     }
 }
 SecureStorage.instance = null;
 
-const secureStorage$2 = SecureStorage.getInstance();
+const secureStorage$1 = SecureStorage.getInstance();
 /**
  * Función de debug para verificar el estado del sistema de encriptación
  * Muestra información detallada en la consola
@@ -1167,7 +1171,7 @@ async function debugEncryptionState() {
     console.group('🔐 Estado del Sistema de Encriptación');
     console.log('Soporte Crypto API:', EncryptionHelper.isSupported());
     // Obtener información de debug
-    const debugInfo = secureStorage$2.getDebugInfo();
+    const debugInfo = secureStorage$1.getDebugInfo();
     console.log('Claves encriptadas:', debugInfo.encryptedKeys.length);
     console.log('Claves sin encriptar:', debugInfo.unencryptedKeys);
     console.log('Total de claves:', debugInfo.totalKeys);
@@ -1204,449 +1208,23 @@ async function forceMigration(customKeys) {
     ];
     const keysToMigrate = customKeys || defaultKeys;
     console.log(`🔄 Iniciando migración forzada de ${keysToMigrate.length} claves...`);
-    await secureStorage$2.migrateExistingData(keysToMigrate);
+    await secureStorage$1.migrateExistingData(keysToMigrate);
     console.log('✅ Migración forzada completada');
     // Mostrar estado después de la migración
     await debugEncryptionState();
 }
 
-// Allow custom storage instance or use default
-let defaultStorage = null;
-function getDefaultStorage() {
-    if (!defaultStorage) {
-        defaultStorage = SecureStorage.getInstance();
-    }
-    return defaultStorage;
-}
-/**
- * Hook de React para usar SecureStorage de forma reactiva
- * Similar a useState pero con persistencia encriptada
- *
- * @param key - Clave para almacenar en localStorage
- * @param initialValue - Valor inicial si no existe en storage
- * @param storage - Instancia personalizada de SecureStorage (opcional)
- * @returns [value, setValue, loading, error]
- *
- * @example
- * const [token, setToken, loading] = useSecureStorage('accessToken', '');
- */
-function useSecureStorage(key, initialValue, storage) {
-    const secureStorage = storage || getDefaultStorage();
-    const [storedValue, setStoredValue] = useState(initialValue);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    // Cargar valor inicial
-    useEffect(() => {
-        const loadValue = async () => {
-            try {
-                setLoading(true);
-                setError(null);
-                const item = await secureStorage.getItem(key);
-                if (item !== null) {
-                    // Si T es un objeto, parsear JSON
-                    if (typeof initialValue === 'object') {
-                        setStoredValue(JSON.parse(item));
-                    }
-                    else {
-                        setStoredValue(item);
-                    }
-                }
-                else {
-                    setStoredValue(initialValue);
-                }
-            }
-            catch (err) {
-                setError(err instanceof Error ? err : new Error('Error al cargar valor'));
-                setStoredValue(initialValue);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        loadValue();
-    }, [key]); // Solo recargar si cambia la clave
-    // Función para actualizar el valor
-    const setValue = useCallback(async (value) => {
-        try {
-            setError(null);
-            setStoredValue(value);
-            // Si T es un objeto, convertir a JSON
-            const valueToStore = typeof value === 'object'
-                ? JSON.stringify(value)
-                : String(value);
-            await secureStorage.setItem(key, valueToStore);
-        }
-        catch (err) {
-            setError(err instanceof Error ? err : new Error('Error al guardar valor'));
-            throw err;
-        }
-    }, [key, secureStorage]);
-    return [storedValue, setValue, loading, error];
-}
-/**
- * Hook para verificar si una clave existe en SecureStorage
- *
- * @param key - Clave a verificar
- * @param storage - Instancia personalizada de SecureStorage (opcional)
- * @returns [exists, loading, error]
- *
- * @example
- * const [hasToken, loading] = useSecureStorageItem('accessToken');
- */
-function useSecureStorageItem(key, storage) {
-    const secureStorage = storage || getDefaultStorage();
-    const [exists, setExists] = useState(false);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        const checkExists = async () => {
-            try {
-                setLoading(true);
-                setError(null);
-                const hasItem = await secureStorage.hasItem(key);
-                setExists(hasItem);
-            }
-            catch (err) {
-                setError(err instanceof Error ? err : new Error('Error al verificar clave'));
-                setExists(false);
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        checkExists();
-    }, [key, secureStorage]);
-    return [exists, loading, error];
-}
-/**
- * Hook para obtener información de debug del almacenamiento
- *
- * @param storage - Instancia personalizada de SecureStorage (opcional)
- * @returns Información de debug
- *
- * @example
- * const debugInfo = useSecureStorageDebug();
- * console.log(`Claves encriptadas: ${debugInfo.encryptedKeys.length}`);
- */
-function useSecureStorageDebug(storage) {
-    const secureStorage = storage || getDefaultStorage();
-    const [debugInfo, setDebugInfo] = useState(secureStorage.getDebugInfo());
-    useEffect(() => {
-        // Actualizar cada segundo
-        const interval = setInterval(() => {
-            setDebugInfo(secureStorage.getDebugInfo());
-        }, 1000);
-        return () => clearInterval(interval);
-    }, [secureStorage]);
-    return debugInfo;
-}
-/**
- * Exportar la instancia de SecureStorage para uso directo
- */
-const secureStorage$1 = getDefaultStorage();
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-}
-function __runInitializers(thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-}
-function __setFunctionName(f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-}
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-/**
- * Servicio de Angular para SecureStorage v2
- * Proporciona una API reactiva usando RxJS Observables
- *
- * @example
- * constructor(private secureStorage: SecureStorageService) {}
- *
- * // Guardar
- * this.secureStorage.setItem('token', 'abc123').subscribe();
- *
- * // Leer
- * this.secureStorage.getItem('token').subscribe(token => console.log(token));
- *
- * // Escuchar eventos
- * this.secureStorage.events$.subscribe(event => console.log(event));
- */
-let SecureStorageService = (() => {
-    let _classDecorators = [Injectable({
-            providedIn: 'root'
-        })];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    _classThis = class {
-        constructor(config) {
-            this.debugInfo$ = new BehaviorSubject(this.getDebugInfo());
-            this.eventsSubject$ = new Subject();
-            /**
-             * Observable de eventos de storage
-             */
-            this.events$ = this.eventsSubject$.asObservable();
-            this.storage = SecureStorage.getInstance(config);
-            // Setup event forwarding to Observable
-            this.storage.on('encrypted', (data) => this.eventsSubject$.next(data));
-            this.storage.on('decrypted', (data) => this.eventsSubject$.next(data));
-            this.storage.on('deleted', (data) => this.eventsSubject$.next(data));
-            this.storage.on('cleared', (data) => this.eventsSubject$.next(data));
-            this.storage.on('expired', (data) => this.eventsSubject$.next(data));
-            this.storage.on('error', (data) => this.eventsSubject$.next(data));
-            this.storage.on('keyRotated', (data) => this.eventsSubject$.next(data));
-            this.storage.on('compressed', (data) => this.eventsSubject$.next(data));
-            this.storage.on('decompressed', (data) => this.eventsSubject$.next(data));
-            // Actualizar debug info cada segundo
-            setInterval(() => {
-                this.debugInfo$.next(this.getDebugInfo());
-            }, 1000);
-        }
-        /**
-         * Guarda un valor encriptado
-         * @param key - Clave
-         * @param value - Valor a guardar
-         * @returns Observable que completa cuando se guarda
-         */
-        setItem(key, value) {
-            return from(this.storage.setItem(key, value));
-        }
-        /**
-         * Guarda un valor con expiración
-         * @param key - Clave
-         * @param value - Valor a guardar
-         * @param options - Opciones de expiración
-         * @returns Observable que completa cuando se guarda
-         */
-        setItemWithExpiry(key, value, options) {
-            return from(this.storage.setItemWithExpiry(key, value, options));
-        }
-        /**
-         * Recupera un valor desencriptado
-         * @param key - Clave
-         * @returns Observable con el valor o null
-         */
-        getItem(key) {
-            return from(this.storage.getItem(key));
-        }
-        /**
-         * Elimina un valor
-         * @param key - Clave a eliminar
-         * @returns Observable que completa cuando se elimina
-         */
-        removeItem(key) {
-            return from(this.storage.removeItem(key));
-        }
-        /**
-         * Verifica si existe una clave
-         * @param key - Clave a verificar
-         * @returns Observable con true/false
-         */
-        hasItem(key) {
-            return from(this.storage.hasItem(key));
-        }
-        /**
-         * Limpia todos los datos encriptados
-         */
-        clear() {
-            this.storage.clear();
-        }
-        /**
-         * Limpia todos los items expirados
-         * @returns Observable con el número de items eliminados
-         */
-        cleanExpired() {
-            return from(this.storage.cleanExpired());
-        }
-        /**
-         * Verifica la integridad de un valor
-         * @param key - Clave a verificar
-         * @returns Observable con true si es válido
-         */
-        verifyIntegrity(key) {
-            return from(this.storage.verifyIntegrity(key));
-        }
-        /**
-         * Obtiene información de integridad de un valor
-         * @param key - Clave
-         * @returns Observable con información de integridad
-         */
-        getIntegrityInfo(key) {
-            return from(this.storage.getIntegrityInfo(key));
-        }
-        /**
-         * Crea un namespace para organizar datos
-         * @param name - Nombre del namespace
-         * @returns Instancia de NamespacedStorage
-         */
-        namespace(name) {
-            return this.storage.namespace(name);
-        }
-        /**
-         * Rota todas las claves de encriptación
-         * @returns Observable que completa cuando termina la rotación
-         */
-        rotateKeys() {
-            return from(this.storage.rotateKeys());
-        }
-        /**
-         * Exporta todos los datos como backup
-         * @returns Observable con el backup
-         */
-        exportEncryptedData() {
-            return from(this.storage.exportEncryptedData());
-        }
-        /**
-         * Importa datos desde un backup
-         * @param backup - Backup a importar
-         * @returns Observable que completa cuando termina la importación
-         */
-        importEncryptedData(backup) {
-            return from(this.storage.importEncryptedData(backup));
-        }
-        /**
-         * Migra datos existentes a formato encriptado
-         * @param keys - Array de claves a migrar
-         * @returns Observable que completa cuando termina la migración
-         */
-        migrateExistingData(keys) {
-            return from(this.storage.migrateExistingData(keys));
-        }
-        /**
-         * Obtiene información de debug como Observable
-         * @returns Observable con información de debug que se actualiza automáticamente
-         */
-        getDebugInfo$() {
-            return this.debugInfo$.asObservable();
-        }
-        /**
-         * Obtiene información de debug de forma síncrona
-         */
-        getDebugInfo() {
-            return this.storage.getDebugInfo();
-        }
-        /**
-         * Helper para guardar objetos JSON
-         * @param key - Clave
-         * @param value - Objeto a guardar
-         */
-        setObject(key, value) {
-            return this.setItem(key, JSON.stringify(value));
-        }
-        /**
-         * Helper para guardar objetos JSON con expiración
-         * @param key - Clave
-         * @param value - Objeto a guardar
-         * @param options - Opciones de expiración
-         */
-        setObjectWithExpiry(key, value, options) {
-            return this.setItemWithExpiry(key, JSON.stringify(value), options);
-        }
-        /**
-         * Helper para recuperar objetos JSON
-         * @param key - Clave
-         * @returns Observable con el objeto parseado o null
-         */
-        getObject(key) {
-            return this.getItem(key).pipe(map(value => value ? JSON.parse(value) : null), catchError(() => from([null])));
-        }
-        /**
-         * Registra un listener para un tipo de evento específico
-         * @param event - Tipo de evento
-         * @param handler - Función manejadora
-         */
-        on(event, handler) {
-            this.storage.on(event, handler);
-        }
-        /**
-         * Elimina un listener de evento
-         * @param event - Tipo de evento
-         * @param handler - Función manejadora
-         */
-        off(event, handler) {
-            this.storage.off(event, handler);
-        }
-        /**
-         * Observable filtrado por tipo de evento
-         * @param eventType - Tipo de evento a filtrar
-         * @returns Observable con eventos del tipo especificado
-         */
-        onEvent$(eventType) {
-            return this.events$.pipe(map(event => event.type === eventType ? event : null), map(event => event));
-        }
-    };
-    __setFunctionName(_classThis, "SecureStorageService");
-    (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-        _classThis = _classDescriptor.value;
-        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        __runInitializers(_classThis, _classExtraInitializers);
-    })();
-    return _classThis;
-})();
-
 /**
- * @bantis/local-cipher v2.0.0
- * Librería de cifrado local AES-256-GCM para Angular, React y JavaScript
+ * @bantis/local-cipher - Core Module
+ * Framework-agnostic client-side encryption for browser storage
  *
- * @author MTT
+ * @version 2.1.0
  * @license MIT
  */
-// Core exports
+// Core classes
 const secureStorage = SecureStorage.getInstance();
 // Version
-const VERSION = '2.0.0';
+const VERSION = '2.1.0';
 
-export { DEFAULT_CONFIG, EncryptionHelper, EventEmitter, KeyRotation, LIBRARY_VERSION, Logger, NamespacedStorage, STORAGE_VERSION, SecureStorage, SecureStorageService, VERSION, compress, debugEncryptionState, decompress, forceMigration, isCompressionSupported, secureStorage$1 as reactSecureStorage, secureStorage, shouldCompress, useSecureStorage, useSecureStorageDebug, useSecureStorageItem };
+export { DEFAULT_CONFIG, EncryptionHelper, EventEmitter, KeyRotation, LIBRARY_VERSION, Logger, NamespacedStorage, STORAGE_VERSION, SecureStorage, VERSION, compress, debugEncryptionState, decompress, forceMigration, isCompressionSupported, secureStorage, shouldCompress };
 //# sourceMappingURL=index.esm.js.map