@shival99/z-ui 1.2.18 → 1.2.19

package/fesm2022/shival99-z-ui-services.mjs

@@ -924,6 +924,8 @@ const Z_INDEXDB_DEFAULT_CONFIG = {
     defaultStore: 'ZStore',
 };
 const Z_INDEXDB_BATCH_SIZE = 100;
+const Z_INDEXDB_MAX_VERSION = 1000;
+
 class ZIndexDbService {
     _db = null;
     _dbName;
@@ -978,7 +980,6 @@ class ZIndexDbService {
         }
     }
     async _reconnect() {
-        console.warn('[ZIndexDb] Reconnecting...');
         this._closeConnection();
         this._dbReady = this._initDb();
         await this._dbReady;
@@ -1003,11 +1004,25 @@ class ZIndexDbService {
         if (this._db) {
             return;
         }
+        const currentVersion = await this._getCurrentDbVersion();
+        if (currentVersion >= Z_INDEXDB_MAX_VERSION) {
+            await this._resetDatabase();
+            this._version = 1;
+        }
+        else if (currentVersion > this._version) {
+            this._version = currentVersion;
+        }
         return new Promise((resolve, reject) => {
             try {
                 const request = indexedDB.open(this._dbName, this._version);
                 request.onupgradeneeded = event => {
                     const db = event.target.result;
+                    const existingStores = Array.from(db.objectStoreNames);
+                    existingStores.forEach(storeName => {
+                        if (!this._stores.has(storeName)) {
+                            db.deleteObjectStore(storeName);
+                        }
+                    });
                     this._stores.forEach((_, storeName) => {
                         if (!db.objectStoreNames.contains(storeName)) {
                             db.createObjectStore(storeName);
@@ -1016,11 +1031,16 @@ class ZIndexDbService {
                 };
                 request.onsuccess = event => {
                     this._db = event.target.result;
+                    this._version = this._db.version;
                     this._db.onerror = e => console.error('[ZIndexDb] Error:', e.target.error);
                     this._db.onclose = () => {
-                        console.warn('[ZIndexDb] Connection closed unexpectedly');
                         this._db = null;
                     };
+                    const missingStores = this._getMissingStores();
+                    if (missingStores.length > 0) {
+                        this._triggerUpgrade().then(resolve).catch(reject);
+                        return;
+                    }
                     resolve();
                 };
                 request.onerror = event => {
@@ -1033,12 +1053,57 @@ class ZIndexDbService {
             }
         });
     }
-    /**
-     * Get a value from the store
-     * @param key - The key to retrieve
-     * @param defaultValue - Default value if key not found
-     * @param storeName - Optional store name (uses default if not specified)
-     */
+    _getCurrentDbVersion() {
+        return new Promise(resolve => {
+            const request = indexedDB.open(this._dbName);
+            request.onsuccess = event => {
+                const db = event.target.result;
+                const { version } = db;
+                db.close();
+                resolve(version);
+            };
+            request.onerror = () => {
+                resolve(1);
+            };
+        });
+    }
+    async _triggerUpgrade() {
+        this._closeConnection();
+        if (this._version >= Z_INDEXDB_MAX_VERSION) {
+            await this._resetDatabase();
+            this._version = 1;
+        }
+        else {
+            this._version += 1;
+        }
+        this._dbReady = this._initDb();
+        await this._dbReady;
+    }
+    async _resetDatabase() {
+        this._closeConnection();
+        return new Promise((resolve, reject) => {
+            const deleteRequest = indexedDB.deleteDatabase(this._dbName);
+            deleteRequest.onsuccess = () => resolve();
+            deleteRequest.onerror = () => reject(deleteRequest.error);
+            deleteRequest.onblocked = () => {
+                setTimeout(() => this._resetDatabase().then(resolve).catch(reject), 100);
+            };
+        });
+    }
+    _getMissingStores() {
+        if (!this._db) {
+            return [];
+        }
+        const existingStores = Array.from(this._db.objectStoreNames);
+        const requiredStores = Array.from(this._stores.keys());
+        return requiredStores.filter(store => !existingStores.includes(store));
+    }
+    _ensureStoreExists(storeName) {
+        if (!this._db) {
+            return false;
+        }
+        return this._db.objectStoreNames.contains(storeName);
+    }
     async get(key, defaultValue, storeName) {
         const storeConfig = this._getStoreConfig(storeName);
         return this._withRetry(async () => {
@@ -1049,6 +1114,12 @@ class ZIndexDbService {
                     return defaultValue;
                 }
             }
+            if (!this._ensureStoreExists(storeConfig.name)) {
+                await this._triggerUpgrade();
+                if (!this._ensureStoreExists(storeConfig.name)) {
+                    return defaultValue;
+                }
+            }
             const _key = storeConfig.encrypt !== false ? this._encrypt(key) : key;
             return new Promise(resolve => {
                 try {
@@ -1078,12 +1149,6 @@ class ZIndexDbService {
             });
         });
     }
-    /**
-     * Set a value in the store
-     * @param key - The key to set
-     * @param value - The value to store
-     * @param storeName - Optional store name
-     */
     async set(key, value, storeName) {
         const storeConfig = this._getStoreConfig(storeName);
         return this._withRetry(async () => {
@@ -1094,6 +1159,12 @@ class ZIndexDbService {
                     throw new Error('Database not initialized');
                 }
             }
+            if (!this._ensureStoreExists(storeConfig.name)) {
+                await this._triggerUpgrade();
+                if (!this._ensureStoreExists(storeConfig.name)) {
+                    throw new Error(`Failed to create store "${storeConfig.name}"`);
+                }
+            }
             const _key = storeConfig.encrypt !== false ? this._encrypt(key) : key;
             const _value = storeConfig.encrypt !== false ? this._encrypt(value) : value;
             return new Promise((resolve, reject) => {
@@ -1111,11 +1182,6 @@ class ZIndexDbService {
             });
         });
     }
-    /**
-     * Delete a key from the store
-     * @param key - Key or array of keys to delete
-     * @param storeName - Optional store name
-     */
     async delete(key, storeName) {
         const storeConfig = this._getStoreConfig(storeName);
         return this._withRetry(async () => {
@@ -1126,6 +1192,9 @@ class ZIndexDbService {
                     throw new Error('Database not initialized');
                 }
             }
+            if (!this._ensureStoreExists(storeConfig.name)) {
+                return;
+            }
             const keys = Array.isArray(key) ? key : [key];
             return new Promise((resolve, reject) => {
                 try {
@@ -1144,10 +1213,6 @@ class ZIndexDbService {
             });
         });
     }
-    /**
-     * Clear all data from a store (respecting protected keys)
-     * @param storeName - Optional store name
-     */
     async clear(storeName) {
         const storeConfig = this._getStoreConfig(storeName);
         const protectedKeys = [...this._globalProtectedKeys, ...(storeConfig.protectedKeys ?? [])];
@@ -1159,6 +1224,9 @@ class ZIndexDbService {
                     throw new Error('Database not initialized');
                 }
             }
+            if (!this._ensureStoreExists(storeConfig.name)) {
+                return;
+            }
             if (protectedKeys.length === 0) {
                 return new Promise((resolve, reject) => {
                     const transaction = this._db.transaction([storeConfig.name], 'readwrite');
@@ -1200,10 +1268,6 @@ class ZIndexDbService {
             });
         });
     }
-    /**
-     * Get all items from a store
-     * @param storeName - Optional store name
-     */
     async getAll(storeName) {
         const storeConfig = this._getStoreConfig(storeName);
         return this._withRetry(async () => {
@@ -1214,6 +1278,9 @@ class ZIndexDbService {
                     return {};
                 }
             }
+            if (!this._ensureStoreExists(storeConfig.name)) {
+                return {};
+            }
             return new Promise(resolve => {
                 try {
                     const transaction = this._db.transaction([storeConfig.name], this._mode);
@@ -1234,7 +1301,7 @@ class ZIndexDbService {
                                     }
                                 }
                                 catch {
-                                    // Skip invalid entries
+                                    // Skip
                                 }
                             }
                         });
@@ -1249,14 +1316,13 @@ class ZIndexDbService {
             });
         });
     }
-    /**
-     * Set multiple items at once
-     * @param items - Object with key-value pairs
-     * @param storeName - Optional store name
-     */
     async setMultiple(items, storeName) {
         const storeConfig = this._getStoreConfig(storeName);
         const entries = Object.entries(items);
+        await this._dbReady;
+        if (this._db && !this._ensureStoreExists(storeConfig.name)) {
+            await this._triggerUpgrade();
+        }
         for (let i = 0; i < entries.length; i += Z_INDEXDB_BATCH_SIZE) {
             const batch = entries.slice(i, i + Z_INDEXDB_BATCH_SIZE);
             await this._withRetry(async () => {
@@ -1267,6 +1333,9 @@ class ZIndexDbService {
                         throw new Error('Database not initialized');
                     }
                 }
+                if (!this._ensureStoreExists(storeConfig.name)) {
+                    throw new Error(`Store "${storeConfig.name}" does not exist`);
+                }
                 return new Promise((resolve, reject) => {
                     const transaction = this._db.transaction([storeConfig.name], 'readwrite');
                     const store = transaction.objectStore(storeConfig.name);
@@ -1281,40 +1350,26 @@ class ZIndexDbService {
             });
         }
     }
-    /**
-     * Get the list of available store names
-     */
     getStoreNames() {
         return Array.from(this._stores.keys());
     }
-    /**
-     * Check if a store exists
-     * @param storeName - Store name to check
-     */
     hasStore(storeName) {
         return this._stores.has(storeName);
     }
-    /**
-     * Add a new store (requires database version upgrade)
-     * Note: This will cause database reconnection
-     * @param config - Store configuration
-     */
     async addStore(config) {
         if (this._stores.has(config.name)) {
             return;
         }
         this._stores.set(config.name, config);
-        this._version += 1;
-        this._closeConnection();
-        this._dbReady = this._initDb();
-        await this._dbReady;
+        await this._triggerUpgrade();
     }
 }
 
 const Z_THEME_CONFIG = new InjectionToken('Z_THEME_CONFIG');
 const Z_DEFAULT_THEME = 'neutral';
-const Z_THEME_CACHE_KEY = 'z-theme';
-const Z_DARK_MODE_CACHE_KEY = 'z-dark-mode';
+const Z_THEME_CACHE_KEY = 'Z_THEME';
+const Z_DARK_MODE_CACHE_KEY = 'Z_DARK_MODE';
+const Z_THEME_CONFIG_CACHE_KEY = 'Z_THEME_CONFIG';
 const Z_THEME_CSS_MAP = {
     neutral: '',
     green: 'assets/css/themes/green.css',
@@ -1415,8 +1470,8 @@ class ZHttpAbstractService {
     constructor() {
         this.indexDbService = new ZIndexDbService({
             dbName: 'ZHttpCache',
-            defaultStore: 'HttpCache',
-            stores: [{ name: 'HttpCache', encrypt: true }],
+            defaultStore: 'zHttpCache',
+            stores: [{ name: 'zHttpCache', encrypt: true }],
         });
     }
     get(endpoint, options) {
@@ -1843,13 +1898,14 @@ class ZThemeService {
     _isBrowser = isPlatformBrowser(this._platformId);
     _defaultTheme = this._config?.defaultTheme ?? Z_DEFAULT_THEME;
     _defaultDarkMode = this._config?.defaultDarkMode ?? false;
-    _isDark = signal(this._getSavedDarkMode(), ...(ngDevMode ? [{ debugName: "_isDark" }] : []));
-    _currentTheme = signal(this._getSavedTheme(), ...(ngDevMode ? [{ debugName: "_currentTheme" }] : []));
+    _isDark = signal(this._getInitialDarkMode(), ...(ngDevMode ? [{ debugName: "_isDark" }] : []));
+    _currentTheme = signal(this._getInitialTheme(), ...(ngDevMode ? [{ debugName: "_currentTheme" }] : []));
     _loadedThemes = new Set(['neutral']);
     isDark = this._isDark.asReadonly();
     currentTheme = this._currentTheme.asReadonly();
     constructor() {
         if (this._isBrowser) {
+            this._syncConfigToCache();
             this._initializeTheme();
         }
         effect(() => {
@@ -1901,18 +1957,43 @@ class ZThemeService {
             this.toggleDarkMode(savedDarkMode);
         }
     }
-    _getSavedTheme() {
+    _getInitialTheme() {
         if (!this._isBrowser) {
             return this._defaultTheme;
         }
+        if (this._hasConfigChanged()) {
+            return this._defaultTheme;
+        }
         return ZCacheService.get(Z_THEME_CACHE_KEY) ?? this._defaultTheme;
     }
-    _getSavedDarkMode() {
+    _getInitialDarkMode() {
         if (!this._isBrowser) {
             return this._defaultDarkMode;
         }
+        if (this._hasConfigChanged()) {
+            return this._defaultDarkMode;
+        }
         return ZCacheService.get(Z_DARK_MODE_CACHE_KEY) ?? this._defaultDarkMode;
     }
+    _hasConfigChanged() {
+        const cachedConfig = ZCacheService.get(Z_THEME_CONFIG_CACHE_KEY);
+        if (!cachedConfig) {
+            return false;
+        }
+        const currentConfig = {
+            defaultTheme: this._defaultTheme,
+            defaultDarkMode: this._defaultDarkMode,
+        };
+        return (cachedConfig.defaultTheme !== currentConfig.defaultTheme ||
+            cachedConfig.defaultDarkMode !== currentConfig.defaultDarkMode);
+    }
+    _syncConfigToCache() {
+        const currentConfig = {
+            defaultTheme: this._defaultTheme,
+            defaultDarkMode: this._defaultDarkMode,
+        };
+        ZCacheService.set(Z_THEME_CONFIG_CACHE_KEY, currentConfig);
+    }
     _loadThemeCSS(theme, onLoad) {
         const cssPath = Z_THEME_CSS_MAP[theme];
         if (!cssPath) {
@@ -1953,5 +2034,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ZCacheService, ZExcelService, ZHttpAbstractService, ZIndexDbService, ZSubjectService, ZThemeService, ZTranslateService, Z_DARK_MODE_CACHE_KEY, Z_DEFAULT_THEME, Z_EXCEL_BORDER_THIN, Z_EXCEL_CHAR_WIDTH_MAP, Z_EXCEL_COLORS, Z_EXCEL_DEFAULT_CONFIG, Z_EXCEL_FONT_MULTIPLIERS, Z_EXCEL_WIDTH_LIMITS, Z_LANG_CACHE_KEY, Z_THEME_CACHE_KEY, Z_THEME_CONFIG, Z_THEME_CSS_MAP };
+export { ZCacheService, ZExcelService, ZHttpAbstractService, ZIndexDbService, ZSubjectService, ZThemeService, ZTranslateService, Z_DARK_MODE_CACHE_KEY, Z_DEFAULT_THEME, Z_EXCEL_BORDER_THIN, Z_EXCEL_CHAR_WIDTH_MAP, Z_EXCEL_COLORS, Z_EXCEL_DEFAULT_CONFIG, Z_EXCEL_FONT_MULTIPLIERS, Z_EXCEL_WIDTH_LIMITS, Z_INDEXDB_BATCH_SIZE, Z_INDEXDB_DEFAULT_CONFIG, Z_INDEXDB_MAX_VERSION, Z_LANG_CACHE_KEY, Z_THEME_CACHE_KEY, Z_THEME_CONFIG, Z_THEME_CONFIG_CACHE_KEY, Z_THEME_CSS_MAP };
 //# sourceMappingURL=shival99-z-ui-services.mjs.map