@shival99/z-ui 1.9.13 → 1.9.14

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

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { Injectable, InjectionToken, inject, DestroyRef, signal, computed, PLATFORM_ID, effect } from '@angular/core';
-import { zFormatNumExcel, zConvertColorToArgb } from '@shival99/z-ui/utils';
+import { zNormalize, zFormatNumExcel, zConvertColorToArgb } from '@shival99/z-ui/utils';
 import * as ExcelJS from 'exceljs';
 import { saveAs } from 'file-saver';
 import * as XLSX from 'xlsx';
@@ -11,137 +11,51 @@ import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { TranslateService } from '@ngx-translate/core';
 import { isPlatformBrowser, DOCUMENT } from '@angular/common';
 
-class ZCacheService {
-    static _prefix = 'z_';
-    static _encrypt = true;
-    static configure(config) {
-        if (config.prefix) {
-            ZCacheService._prefix = config.prefix;
-        }
-        if (config.encrypt !== undefined) {
-            ZCacheService._encrypt = config.encrypt;
-        }
-    }
-    static _encode(data) {
-        const payload = { __z: true, __d: data };
-        return btoa(encodeURIComponent(JSON.stringify(payload)));
-    }
-    static _decode(data) {
-        try {
-            const decoded = JSON.parse(decodeURIComponent(atob(data)));
-            if (!decoded.__z) {
-                return null;
-            }
-            return decoded.__d;
-        }
-        catch {
-            return null;
-        }
-    }
-    static _normalizeKey(key) {
-        return key.toLowerCase();
-    }
-    static _getFullKey(key, encrypt) {
-        const normalizedKey = ZCacheService._normalizeKey(key);
-        const prefixedKey = `${ZCacheService._prefix}${normalizedKey}`;
-        return encrypt ? ZCacheService._encode(prefixedKey) : prefixedKey;
-    }
-    static _decodeStorageKey(storageKey) {
-        const decoded = ZCacheService._decode(storageKey);
-        if (typeof decoded !== 'string') {
-            return null;
-        }
-        return decoded;
-    }
-    static _isManagedStorageKey(storageKey) {
-        if (storageKey.startsWith(ZCacheService._prefix)) {
-            return true;
-        }
-        const decoded = ZCacheService._decodeStorageKey(storageKey);
-        if (!decoded) {
-            return false;
-        }
-        return decoded.startsWith(ZCacheService._prefix);
-    }
-    static _safeOperation(operation, fallback) {
-        try {
-            return operation();
-        }
-        catch (error) {
-            console.error('[ZCache] Operation error:', error);
-            return fallback;
-        }
-    }
-    static get(key, defaultValue, encrypt = ZCacheService._encrypt) {
-        return ZCacheService._safeOperation(() => {
-            const _key = ZCacheService._getFullKey(key, encrypt);
-            const result = localStorage.getItem(_key);
-            if (!result) {
-                return defaultValue;
-            }
-            const data = encrypt ? ZCacheService._decode(result) : JSON.parse(result);
-            return data ?? defaultValue;
-        }, defaultValue);
-    }
-    static set(key, data, encrypt = ZCacheService._encrypt) {
-        return ZCacheService._safeOperation(() => {
-            const _key = ZCacheService._getFullKey(key, encrypt);
-            const _value = encrypt ? ZCacheService._encode(data) : JSON.stringify(data);
-            localStorage.setItem(_key, _value);
-            return true;
-        }, false);
-    }
-    static delete(key) {
-        return ZCacheService._safeOperation(() => {
-            const encryptedKey = ZCacheService._getFullKey(key, true);
-            const plainKey = ZCacheService._getFullKey(key, false);
-            localStorage.removeItem(encryptedKey);
-            localStorage.removeItem(plainKey);
-            return true;
-        }, false);
-    }
-    static deleteMultiple(keys) {
-        return ZCacheService._safeOperation(() => {
-            keys.forEach(key => {
-                const encryptedKey = ZCacheService._getFullKey(key, true);
-                const plainKey = ZCacheService._getFullKey(key, false);
-                localStorage.removeItem(encryptedKey);
-                localStorage.removeItem(plainKey);
-            });
-            return true;
-        }, false);
-    }
-    static clear() {
-        return ZCacheService._safeOperation(() => {
-            const keysToRemove = [];
-            for (let i = 0; i < localStorage.length; i++) {
-                const key = localStorage.key(i);
-                if (!key) {
-                    continue;
-                }
-                if (ZCacheService._isManagedStorageKey(key)) {
-                    keysToRemove.push(key);
-                }
-            }
-            keysToRemove.forEach(key => localStorage.removeItem(key));
-            return true;
-        }, false);
+const Z_CACHE_SCOPE_SEPARATOR = '::';
+const Z_DB_SCOPE_SEPARATOR = '__';
+const Z_SCOPE_FALLBACK = 'global';
+const Z_RUNTIME_SCOPE = (() => {
+    if (typeof window === 'undefined') {
+        return Z_SCOPE_FALLBACK;
+    }
+    const origin = zNormalize(window.location.origin);
+    const baseHref = typeof document !== 'undefined' ? zNormalize(document.querySelector('base')?.getAttribute('href') ?? '') : '';
+    if (!origin && !baseHref) {
+        return Z_SCOPE_FALLBACK;
+    }
+    if (!origin) {
+        return baseHref || Z_SCOPE_FALLBACK;
+    }
+    if (!baseHref) {
+        return origin;
+    }
+    return `${origin}__${baseHref}`;
+})();
+const Z_CACHE_SCOPE_SUFFIX = `${Z_CACHE_SCOPE_SEPARATOR}${Z_RUNTIME_SCOPE}`;
+const Z_DB_SCOPE_SUFFIX = `${Z_DB_SCOPE_SEPARATOR}${Z_RUNTIME_SCOPE}`;
+function zAppendScope(value, scopeSuffix) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.endsWith(scopeSuffix)) {
+        return value;
+    }
+    return `${trimmed}${scopeSuffix}`;
+}
+function zBuildScopedCacheKey(baseKey) {
+    return zAppendScope(baseKey, Z_CACHE_SCOPE_SUFFIX);
+}
+function zBuildScopedDbName(baseDbName) {
+    return zAppendScope(baseDbName, Z_DB_SCOPE_SUFFIX);
+}
+function zStripScopedCacheKey(key) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey) {
+        return key;
     }
-    static has(key, encrypt = ZCacheService._encrypt) {
-        return ZCacheService._safeOperation(() => {
-            const _key = ZCacheService._getFullKey(key, encrypt);
-            return localStorage.getItem(_key) !== null;
-        }, false);
+    if (!normalizedKey.endsWith(Z_CACHE_SCOPE_SUFFIX)) {
+        return normalizedKey;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZCacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZCacheService, providedIn: 'root' });
+    return normalizedKey.slice(0, normalizedKey.length - Z_CACHE_SCOPE_SUFFIX.length);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZCacheService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
 
 const Z_EXCEL_COLORS = {
     'green-50': 'FFF0FDF4',
@@ -256,6 +170,185 @@ const Z_EXCEL_WIDTH_LIMITS = {
     default: 20,
 };
 
+const Z_INDEXDB_DEFAULT_CONFIG = {
+    dbName: 'ZDatabase',
+    version: 1,
+    mode: 'readwrite',
+    defaultStore: 'ZStore',
+};
+const Z_INDEXDB_BATCH_SIZE = 100;
+const Z_INDEXDB_MAX_VERSION = 1000;
+
+const Z_LANG_TO_LOCALE = {
+    vi: 'vi-VN',
+    en: 'en-US',
+};
+
+class ZCacheService {
+    static _prefix = 'z_';
+    static _encrypt = true;
+    static configure(config) {
+        if (config.prefix) {
+            ZCacheService._prefix = config.prefix;
+        }
+        if (config.encrypt !== undefined) {
+            ZCacheService._encrypt = config.encrypt;
+        }
+    }
+    static _encode(data) {
+        const payload = { __z: true, __d: data };
+        return btoa(encodeURIComponent(JSON.stringify(payload)));
+    }
+    static _decode(data) {
+        try {
+            const decoded = JSON.parse(decodeURIComponent(atob(data)));
+            if (!decoded.__z) {
+                return null;
+            }
+            return decoded.__d;
+        }
+        catch {
+            return null;
+        }
+    }
+    static _normalizeLegacyKey(key) {
+        return key.trim().toLowerCase();
+    }
+    static _normalizeKey(key) {
+        return zBuildScopedCacheKey(ZCacheService._normalizeLegacyKey(key));
+    }
+    static _toStorageKey(normalizedKey, encrypt) {
+        const prefixedKey = `${ZCacheService._prefix}${normalizedKey}`;
+        return encrypt ? ZCacheService._encode(prefixedKey) : prefixedKey;
+    }
+    static _getFullKey(key, encrypt) {
+        return ZCacheService._toStorageKey(ZCacheService._normalizeKey(key), encrypt);
+    }
+    static _getLegacyFullKey(key, encrypt) {
+        const legacyNormalized = ZCacheService._normalizeLegacyKey(key);
+        const scopedNormalized = ZCacheService._normalizeKey(key);
+        if (legacyNormalized === scopedNormalized) {
+            return null;
+        }
+        return ZCacheService._toStorageKey(legacyNormalized, encrypt);
+    }
+    static _getCandidateStorageKeys(key, encrypt) {
+        const scopedKey = ZCacheService._getFullKey(key, encrypt);
+        const legacyKey = ZCacheService._getLegacyFullKey(key, encrypt);
+        return legacyKey ? [scopedKey, legacyKey] : [scopedKey];
+    }
+    static _decodeStorageKey(storageKey) {
+        const decoded = ZCacheService._decode(storageKey);
+        if (typeof decoded !== 'string') {
+            return null;
+        }
+        return decoded;
+    }
+    static _isManagedStorageKey(storageKey) {
+        if (storageKey.startsWith(ZCacheService._prefix)) {
+            return true;
+        }
+        const decoded = ZCacheService._decodeStorageKey(storageKey);
+        if (!decoded) {
+            return false;
+        }
+        return decoded.startsWith(ZCacheService._prefix);
+    }
+    static _safeOperation(operation, fallback) {
+        try {
+            return operation();
+        }
+        catch (error) {
+            console.error('[ZCache] Operation error:', error);
+            return fallback;
+        }
+    }
+    static get(key, defaultValue, encrypt = ZCacheService._encrypt) {
+        return ZCacheService._safeOperation(() => {
+            const candidateKeys = ZCacheService._getCandidateStorageKeys(key, encrypt);
+            for (let i = 0; i < candidateKeys.length; i++) {
+                const result = localStorage.getItem(candidateKeys[i]);
+                if (!result) {
+                    continue;
+                }
+                const data = encrypt ? ZCacheService._decode(result) : JSON.parse(result);
+                if (data === null || data === undefined) {
+                    continue;
+                }
+                if (i > 0) {
+                    const scopedKey = candidateKeys[0];
+                    localStorage.setItem(scopedKey, result);
+                    localStorage.removeItem(candidateKeys[i]);
+                }
+                return data;
+            }
+            return defaultValue;
+        }, defaultValue);
+    }
+    static set(key, data, encrypt = ZCacheService._encrypt) {
+        return ZCacheService._safeOperation(() => {
+            const _key = ZCacheService._getFullKey(key, encrypt);
+            const legacyKey = ZCacheService._getLegacyFullKey(key, encrypt);
+            const _value = encrypt ? ZCacheService._encode(data) : JSON.stringify(data);
+            localStorage.setItem(_key, _value);
+            if (legacyKey) {
+                localStorage.removeItem(legacyKey);
+            }
+            return true;
+        }, false);
+    }
+    static delete(key) {
+        return ZCacheService._safeOperation(() => {
+            const encryptedKeys = ZCacheService._getCandidateStorageKeys(key, true);
+            const plainKeys = ZCacheService._getCandidateStorageKeys(key, false);
+            encryptedKeys.forEach(item => localStorage.removeItem(item));
+            plainKeys.forEach(item => localStorage.removeItem(item));
+            return true;
+        }, false);
+    }
+    static deleteMultiple(keys) {
+        return ZCacheService._safeOperation(() => {
+            keys.forEach(key => {
+                const encryptedKeys = ZCacheService._getCandidateStorageKeys(key, true);
+                const plainKeys = ZCacheService._getCandidateStorageKeys(key, false);
+                encryptedKeys.forEach(item => localStorage.removeItem(item));
+                plainKeys.forEach(item => localStorage.removeItem(item));
+            });
+            return true;
+        }, false);
+    }
+    static clear() {
+        return ZCacheService._safeOperation(() => {
+            const keysToRemove = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (!key) {
+                    continue;
+                }
+                if (ZCacheService._isManagedStorageKey(key)) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach(key => localStorage.removeItem(key));
+            return true;
+        }, false);
+    }
+    static has(key, encrypt = ZCacheService._encrypt) {
+        return ZCacheService._safeOperation(() => {
+            const candidateKeys = ZCacheService._getCandidateStorageKeys(key, encrypt);
+            return candidateKeys.some(storageKey => localStorage.getItem(storageKey) !== null);
+        }, false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZCacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZCacheService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZCacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 class ZExcelService {
     static _isHeaderConfig(config) {
         if (!config || typeof config !== 'object') {
@@ -900,18 +993,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
                 }]
         }] });
 
-const Z_INDEXDB_DEFAULT_CONFIG = {
-    dbName: 'ZDatabase',
-    version: 1,
-    mode: 'readwrite',
-    defaultStore: 'ZStore',
-};
-const Z_INDEXDB_BATCH_SIZE = 100;
-const Z_INDEXDB_MAX_VERSION = 1000;
-
 class ZIndexDbService {
     _db = null;
     _dbName;
+    _legacyDbName = null;
     _version;
     _mode;
     _dbReady;
@@ -920,7 +1005,10 @@ class ZIndexDbService {
     _globalProtectedKeys;
     _encrypt = true;
     constructor(config = {}) {
-        this._dbName = config.dbName ?? Z_INDEXDB_DEFAULT_CONFIG.dbName;
+        const baseDbName = config.dbName ?? Z_INDEXDB_DEFAULT_CONFIG.dbName;
+        const scopedDbName = zBuildScopedDbName(baseDbName);
+        this._dbName = scopedDbName;
+        this._legacyDbName = scopedDbName === baseDbName ? null : baseDbName;
         this._version = config.version ?? Z_INDEXDB_DEFAULT_CONFIG.version;
         this._mode = config.mode ?? Z_INDEXDB_DEFAULT_CONFIG.mode;
         this._defaultStoreName = config.defaultStore ?? Z_INDEXDB_DEFAULT_CONFIG.defaultStore;
@@ -950,8 +1038,25 @@ class ZIndexDbService {
         }
         return storeConfig.encrypt ?? this._encrypt;
     }
+    _normalizeLegacyKey(key) {
+        return key.trim().toLowerCase();
+    }
     _normalizeKey(key) {
-        return key.toLowerCase();
+        return zBuildScopedCacheKey(this._normalizeLegacyKey(key));
+    }
+    _resolveLegacyNormalizedKey(key) {
+        const legacyKey = this._normalizeLegacyKey(key);
+        const scopedKey = this._normalizeKey(key);
+        return legacyKey === scopedKey ? null : legacyKey;
+    }
+    _buildStorageKeys(key, encrypt) {
+        const scopedKey = this._normalizeKey(key);
+        const legacyKey = this._resolveLegacyNormalizedKey(key);
+        const logicalKeys = legacyKey ? [scopedKey, legacyKey] : [scopedKey];
+        if (!encrypt) {
+            return logicalKeys;
+        }
+        return logicalKeys.map(item => this._encryptData(item));
     }
     _encryptData(data) {
         const payload = {
@@ -1004,6 +1109,7 @@ class ZIndexDbService {
         if (this._db) {
             return;
         }
+        await this._adoptLegacyDbNameIfNeeded();
         const currentVersion = await this._getCurrentDbVersion();
         if (currentVersion >= Z_INDEXDB_MAX_VERSION) {
             await this._resetDatabase();
@@ -1053,18 +1159,86 @@ class ZIndexDbService {
             }
         });
     }
-    _getCurrentDbVersion() {
+    async _adoptLegacyDbNameIfNeeded() {
+        if (!this._legacyDbName) {
+            return;
+        }
+        const supportsDatabasesApi = typeof indexedDB.databases === 'function';
+        if (!supportsDatabasesApi) {
+            const scopedMeta = await this._probeDbMetadataByOpen(this._dbName);
+            if (scopedMeta.hasStores) {
+                return;
+            }
+            const legacyMeta = await this._probeDbMetadataByOpen(this._legacyDbName);
+            if (!legacyMeta.hasStores) {
+                return;
+            }
+            this._dbName = this._legacyDbName;
+            this._version = Math.max(this._version, legacyMeta.version);
+            this._legacyDbName = null;
+            return;
+        }
+        const scopedVersion = await this._getExistingDbVersion(this._dbName);
+        if (scopedVersion > 0) {
+            return;
+        }
+        const legacyVersion = await this._getExistingDbVersion(this._legacyDbName);
+        if (legacyVersion <= 0) {
+            return;
+        }
+        this._dbName = this._legacyDbName;
+        this._version = Math.max(this._version, legacyVersion);
+        this._legacyDbName = null;
+    }
+    _getExistingDbVersion(dbName) {
+        const databasesApi = indexedDB.databases;
+        if (!databasesApi) {
+            return Promise.resolve(0);
+        }
+        return databasesApi
+            .call(indexedDB)
+            .then(databases => {
+            const matchedDb = databases.find(database => database.name === dbName);
+            return typeof matchedDb?.version === 'number' ? matchedDb.version : 0;
+        })
+            .catch(() => 0);
+    }
+    _probeDbMetadataByOpen(dbName) {
         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);
-            };
+            try {
+                const request = indexedDB.open(dbName);
+                request.onsuccess = event => {
+                    const db = event.target.result;
+                    const { version } = db;
+                    const hasStores = db.objectStoreNames.length > 0;
+                    db.close();
+                    if (hasStores || version > 1) {
+                        resolve({ version, hasStores });
+                        return;
+                    }
+                    try {
+                        const deleteRequest = indexedDB.deleteDatabase(dbName);
+                        deleteRequest.onsuccess = () => resolve({ version: 0, hasStores: false });
+                        deleteRequest.onerror = () => resolve({ version: 0, hasStores: false });
+                        deleteRequest.onblocked = () => resolve({ version: 0, hasStores: false });
+                    }
+                    catch {
+                        resolve({ version: 0, hasStores: false });
+                    }
+                };
+                request.onerror = () => resolve({ version: 0, hasStores: false });
+            }
+            catch {
+                resolve({ version: 0, hasStores: false });
+            }
+        });
+    }
+    _getCurrentDbVersion() {
+        return this._getExistingDbVersion(this._dbName).then(version => {
+            if (version > 0) {
+                return version;
+            }
+            return this._probeDbMetadataByOpen(this._dbName).then(metadata => (metadata.version > 0 ? metadata.version : 1));
         });
     }
     async _triggerUpgrade() {
@@ -1120,26 +1294,37 @@ class ZIndexDbService {
                     return defaultValue;
                 }
             }
-            const normalizedKey = this._normalizeKey(key);
-            const _key = shouldEncrypt ? this._encryptData(normalizedKey) : normalizedKey;
+            const storageKeys = this._buildStorageKeys(key, shouldEncrypt);
             return new Promise(resolve => {
                 try {
                     const transaction = this._db.transaction([storeConfig.name], this._mode);
                     const store = transaction.objectStore(storeConfig.name);
-                    const request = store.get(_key);
+                    const request = store.get(storageKeys[0]);
                     request.onsuccess = () => {
-                        try {
-                            const { result } = request;
-                            if (!result) {
+                        const resolveData = (rawValue) => {
+                            try {
+                                if (!rawValue) {
+                                    resolve(defaultValue);
+                                    return;
+                                }
+                                const decrypted = shouldEncrypt ? this._decryptData(rawValue) : rawValue;
+                                resolve(decrypted ?? defaultValue);
+                            }
+                            catch {
                                 resolve(defaultValue);
-                                return;
                             }
-                            const decrypted = shouldEncrypt ? this._decryptData(result) : result;
-                            resolve(decrypted ?? defaultValue);
+                        };
+                        if (request.result) {
+                            resolveData(request.result);
+                            return;
                         }
-                        catch {
+                        if (storageKeys.length < 2) {
                             resolve(defaultValue);
+                            return;
                         }
+                        const legacyRequest = store.get(storageKeys[1]);
+                        legacyRequest.onsuccess = () => resolveData(legacyRequest.result);
+                        legacyRequest.onerror = () => resolve(defaultValue);
                     };
                     request.onerror = () => resolve(defaultValue);
                     transaction.onerror = () => resolve(defaultValue);
@@ -1167,14 +1352,17 @@ class ZIndexDbService {
                     throw new Error(`Failed to create store "${storeConfig.name}"`);
                 }
             }
-            const normalizedKey = this._normalizeKey(key);
-            const _key = shouldEncrypt ? this._encryptData(normalizedKey) : normalizedKey;
+            const storageKeys = this._buildStorageKeys(key, shouldEncrypt);
+            const _key = storageKeys[0];
             const _value = shouldEncrypt ? this._encryptData(value) : value;
             return new Promise((resolve, reject) => {
                 try {
                     const transaction = this._db.transaction([storeConfig.name], 'readwrite');
                     const store = transaction.objectStore(storeConfig.name);
                     const request = store.put(_value, _key);
+                    if (storageKeys.length > 1) {
+                        store.delete(storageKeys[1]);
+                    }
                     request.onerror = () => reject(request.error);
                     transaction.oncomplete = () => resolve();
                     transaction.onerror = () => reject(transaction.error);
@@ -1215,9 +1403,10 @@ class ZIndexDbService {
                     const transaction = this._db.transaction([storeConfig.name], 'readwrite');
                     const store = transaction.objectStore(storeConfig.name);
                     keys.forEach(k => {
-                        const normalizedKey = this._normalizeKey(k);
-                        store.delete(normalizedKey);
-                        store.delete(this._encryptData(normalizedKey));
+                        const plainKeys = this._buildStorageKeys(k, false);
+                        const encryptedKeys = this._buildStorageKeys(k, true);
+                        plainKeys.forEach(item => store.delete(item));
+                        encryptedKeys.forEach(item => store.delete(item));
                     });
                     transaction.oncomplete = () => resolve();
                     transaction.onerror = () => reject(transaction.error);
@@ -1257,17 +1446,22 @@ class ZIndexDbService {
                     const store = transaction.objectStore(storeConfig.name);
                     const keyRequest = store.getAllKeys();
                     const protectedSet = new Set();
+                    const protectedLogicalKeys = new Set();
                     protectedKeys.forEach(k => {
-                        const normalizedKey = this._normalizeKey(k);
-                        protectedSet.add(normalizedKey);
-                        protectedSet.add(this._encryptData(normalizedKey));
+                        const plainKeys = this._buildStorageKeys(k, false);
+                        const encryptedKeys = this._buildStorageKeys(k, true);
+                        plainKeys.forEach(item => {
+                            protectedSet.add(item);
+                            protectedLogicalKeys.add(item);
+                        });
+                        encryptedKeys.forEach(item => protectedSet.add(item));
                     });
                     keyRequest.onsuccess = () => {
                         const allKeys = keyRequest.result;
                         allKeys.forEach(k => {
                             if (!protectedSet.has(k)) {
                                 const decrypted = this._decryptData(k);
-                                if (!decrypted || !protectedKeys.includes(decrypted)) {
+                                if (!decrypted || !protectedLogicalKeys.has(decrypted)) {
                                     store.delete(k);
                                 }
                             }
@@ -1312,7 +1506,7 @@ class ZIndexDbService {
                                     const _key = this._shouldEncrypt(storeConfig) ? this._decryptData(key) : key;
                                     const _value = this._shouldEncrypt(storeConfig) ? this._decryptData(values[index]) : values[index];
                                     if (_key && _value !== null) {
-                                        results[_key] = _value;
+                                        results[zStripScopedCacheKey(_key)] = _value;
                                     }
                                 }
                                 catch {
@@ -1356,10 +1550,13 @@ class ZIndexDbService {
                     const transaction = this._db.transaction([storeConfig.name], 'readwrite');
                     const store = transaction.objectStore(storeConfig.name);
                     batch.forEach(([key, value]) => {
-                        const normalizedKey = this._normalizeKey(key);
-                        const _key = shouldEncrypt ? this._encryptData(normalizedKey) : normalizedKey;
+                        const storageKeys = this._buildStorageKeys(key, shouldEncrypt);
+                        const _key = storageKeys[0];
                         const _value = shouldEncrypt ? this._encryptData(value) : value;
                         store.put(_value, _key);
+                        if (storageKeys.length > 1) {
+                            store.delete(storageKeys[1]);
+                        }
                     });
                     transaction.oncomplete = () => resolve();
                     transaction.onerror = () => reject(transaction.error);
@@ -1386,11 +1583,6 @@ class ZIndexDbService {
     }
 }
 
-const Z_LANG_TO_LOCALE = {
-    vi: 'vi-VN',
-    en: 'en-US',
-};
-
 const Z_THEME_CONFIG = new InjectionToken('Z_THEME_CONFIG');
 const Z_DEFAULT_THEME = 'neutral';
 /** Single cache key for all theme preferences */
@@ -2237,5 +2429,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ZCacheService, ZExcelService, ZHttpAbstractService, ZIndexDbService, ZOverlayContainerService, ZOverlayZIndexService, ZSubjectService, ZThemeService, ZTranslateService, 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_HTTP_DEFAULT_CONFIG, Z_INDEXDB_BATCH_SIZE, Z_INDEXDB_DEFAULT_CONFIG, Z_INDEXDB_MAX_VERSION, Z_LANG_CACHE_KEY, Z_THEME_CONFIG, Z_THEME_CSS_MAP, Z_THEME_PREFERENCES_CACHE_KEY };
+export { ZCacheService, ZExcelService, ZHttpAbstractService, ZIndexDbService, ZOverlayContainerService, ZOverlayZIndexService, ZSubjectService, ZThemeService, ZTranslateService, 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_HTTP_DEFAULT_CONFIG, Z_INDEXDB_BATCH_SIZE, Z_INDEXDB_DEFAULT_CONFIG, Z_INDEXDB_MAX_VERSION, Z_LANG_CACHE_KEY, Z_LANG_TO_LOCALE, Z_THEME_CONFIG, Z_THEME_CSS_MAP, Z_THEME_PREFERENCES_CACHE_KEY, zBuildScopedCacheKey, zBuildScopedDbName, zStripScopedCacheKey };
 //# sourceMappingURL=shival99-z-ui-services.mjs.map