@preference-sl/pref-viewer 2.13.0-beta.13 → 2.13.0-beta.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@preference-sl/pref-viewer",
-    "version": "2.13.0-beta.13",
+    "version": "2.13.0-beta.14",
     "description": "Web Component to preview GLTF models with Babylon.js",
     "author": "Alex Moreno Palacio <amoreno@preference.es>",
     "scripts": {

package/src/gltf-storage.js

@@ -4,6 +4,8 @@
 const PC = (globalThis.PrefConfigurator ??= {});
 PC.version = PC.version ?? "1.0.1"; // bump if your schema changes!!
 PC.db = PC.db ?? null;
+PC.dbName = PC.dbName ?? null;
+PC.storeName = PC.storeName ?? null;
 
 function _getDbOrThrow() {
     const db = PC.db;
@@ -23,22 +25,50 @@ function _openEnsuringStore(dbName, storeName) {
         }
         open.onupgradeneeded = (ev) => {
             const upgradeDb = ev.target.result;
+            const tx = ev.target.transaction;
 
-            // Eliminar la object store si ya existe
-            if (upgradeDb.objectStoreNames.contains(storeName)) {
-                upgradeDb.deleteObjectStore(storeName);
+            let store;
+            if (!upgradeDb.objectStoreNames.contains(storeName)) {
+                store = upgradeDb.createObjectStore(storeName, { keyPath: 'id' });
+            } else if (tx) {
+                store = tx.objectStore(storeName);
             }
 
-            const store = upgradeDb.createObjectStore(storeName, { keyPath: 'id' });
-            store.createIndex('expirationTimeStamp', 'expirationTimeStamp', { unique: false });
+            if (store && !store.indexNames.contains('expirationTimeStamp')) {
+                store.createIndex('expirationTimeStamp', 'expirationTimeStamp', { unique: false });
+            }
         };
     });
 }
 
+function _isRecoverableDbError(err) {
+    const msg = String(err?.message ?? err ?? "");
+    if (!msg) return false;
+    return msg.includes("Database not initialized") ||
+        msg.includes("The database connection is closing") ||
+        msg.includes("InvalidStateError") ||
+        msg.includes("NotFoundError");
+}
+
+async function _withDbRetry(work) {
+    try {
+        return await work(_getDbOrThrow());
+    } catch (e) {
+        if (!_isRecoverableDbError(e) || !PC.dbName || !PC.storeName) {
+            throw e;
+        }
+        await initDb(PC.dbName, PC.storeName);
+        return await work(_getDbOrThrow());
+    }
+}
+
 // --- public API -------------------------------------------------------------
 
 // Inicializar IndexedDB y dejar el handle en PrefConfigurator.db (público)
 export async function initDb(dbName, storeName) {
+    PC.dbName = dbName;
+    PC.storeName = storeName;
+
     const db = await _openEnsuringStore(dbName, storeName);
     // Close any previous handle to avoid versionchange blocking
     try { PC.db?.close?.(); } catch { }
@@ -54,10 +84,7 @@ export async function initDb(dbName, storeName) {
 
 // Guardar modelo
 export async function saveModel(modelDataStr, storeName) {
-    return new Promise((resolve, reject) => {
-        let db;
-        try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
-
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
         let modelData;
         try { modelData = JSON.parse(modelDataStr); }
         catch (e) { reject(new Error("saveModel: modelDataStr is not valid JSON")); return; }
@@ -74,59 +101,34 @@ export async function saveModel(modelDataStr, storeName) {
 
         req.onerror = () => reject(req.error);
         req.onsuccess = () => resolve();
-    });
+    }));
 }
 
 // Cargar modelo
 export function loadModel(modelId, storeName) {
-    return new Promise((resolve, reject) => {
-        let db;
-        try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
-
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
         const tx = db.transaction([storeName], "readonly");
         const store = tx.objectStore(storeName);
         const req = store.get(modelId);
 
         req.onerror = () => reject(req.error);
         req.onsuccess = () => resolve(req.result ?? null);
-    });
+    }));
 }
 
 // Descargar archivo desde base64
 export function downloadFileFromBytes(fileName, bytesBase64, mimeType) {
-    let objectURL = null;
     const link = document.createElement("a");
     link.download = fileName;
-    try {
-        const decoded = atob(bytesBase64);
-        const bytes = new Uint8Array(decoded.length);
-        for (let i = 0; i < decoded.length; i++) {
-            bytes[i] = decoded.charCodeAt(i);
-        }
-        const blob = new Blob([bytes], { type: mimeType || "application/octet-stream" });
-        objectURL = URL.createObjectURL(blob);
-        link.href = objectURL;
-    } catch {
-        // Fallback if base64 decoding fails for any reason.
-        link.href = `data:${mimeType};base64,${bytesBase64}`;
-    }
+    link.href = `data:${mimeType};base64,${bytesBase64}`;
     document.body.appendChild(link);
     link.click();
-    link.href = "";
     link.remove();
-    if (objectURL) {
-        setTimeout(() => {
-            URL.revokeObjectURL(objectURL);
-        }, 0);
-    }
 }
 
 // Obtener todos los modelos (solo metadata)
 export async function getAllModels(storeName) {
-    return new Promise((resolve, reject) => {
-        let db;
-        try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
-
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
         const tx = db.transaction([storeName], "readonly");
         const store = tx.objectStore(storeName);
         const req = store.getAll();
@@ -143,45 +145,36 @@ export async function getAllModels(storeName) {
             // keep old behavior: return JSON string
             resolve(JSON.stringify(results));
         };
-    });
+    }));
 }
 
 // Eliminar modelo por id
 export async function deleteModel(modelId, storeName) {
-    return new Promise((resolve, reject) => {
-        let db;
-        try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
-
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
         const tx = db.transaction([storeName], "readwrite");
         const store = tx.objectStore(storeName);
         const req = store.delete(modelId);
 
         req.onerror = () => reject(req.error);
         req.onsuccess = () => resolve();
-    });
+    }));
 }
 
 // Limpiar toda la store
 export async function clearAll(storeName) {
-    return new Promise((resolve, reject) => {
-        let db;
-        try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
-
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
         const tx = db.transaction([storeName], "readwrite");
         const store = tx.objectStore(storeName);
         const req = store.clear();
 
         req.onerror = () => reject(req.error);
         req.onsuccess = () => resolve();
-    });
+    }));
 }
 
 // Borrar modelos expirados usando el índice "expirationTimeStamp"
 export async function cleanExpiredModels(storeName) {
-    return new Promise((resolve, reject) => {
-        let db;
-        try { db = _getDbOrThrow(); } catch (e) { reject(e); return; }
-
+    return _withDbRetry((db) => new Promise((resolve, reject) => {
         const tx = db.transaction([storeName], "readwrite");
         const store = tx.objectStore(storeName);
 
@@ -201,7 +194,7 @@ export async function cleanExpiredModels(storeName) {
 
         tx.oncomplete = () => resolve();
         tx.onerror = () => reject(tx.error);
-    });
+    }));
 }
 
 // Utilidades opcionales y visibles (por si las quieres usar en consola)