@libs-ui/utils 0.2.29 → 0.2.30-6.2

package/esm2022/cache.mjs

@@ -1,87 +1,81 @@
 /* eslint-disable no-async-promise-executor */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { signal } from '@angular/core';
-import { filter } from 'rxjs';
 import { UtilsCommunicateMicro } from './communicate-micro';
 import { decrypt, encrypt, md5 } from './crypto';
 import { getPlatFromBrowser } from './dom';
-import { isNil } from './helpers';
+import { isEmbedFrame } from './function-check-embed-frame';
+import { get, isNil } from './helpers';
 import { UtilsLanguageConstants } from './language';
 import { uuid } from './uuid';
 export class UtilsCache {
+    static CACHE_EXPIRE_TIME_DEFAULT = 5 * 60;
     static CACHE_EXPIRE_NONE = -1;
+    static idService = uuid();
     static typeKeyClearLocalStorage = 'LIBS_UI_CLEAR_LOCAL_STORAGE_EVENT';
-    static listKeyKeepWhenClearALll = Array();
     static languageKeyCache = 'SR3xQKxHgffiCevPQRralg';
+    static listKeyKeepWhenClearALll = Array();
     static initdEvent;
-    static CACHE_EXPIRE_TIME_DEFAULT = 5 * 60;
-    static language = signal(UtilsLanguageConstants.defaultLang);
-    static idService = uuid();
     static storage;
     static dbName = 'libs-ui-cache';
     static itemIndexByKey = 'key';
     static dbVersion = 1;
     static db = null;
     static init(config) {
-        if (UtilsCache.initdEvent) {
+        if (this.initdEvent) {
             return;
         }
-        UtilsCache.initdEvent = true;
+        this.initdEvent = true;
         if (config.indexedDBName) {
-            UtilsCache.dbName = config.indexedDBName;
+            this.dbName = config.indexedDBName;
         }
         if (config.typeKeyClearLocalStorage) {
-            UtilsCache.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;
+            this.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;
         }
-        if (config.listKeyKeepWhenClearALll) {
-            UtilsCache.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearALll;
+        if (config.listKeyKeepWhenClearAll) {
+            this.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearAll;
         }
         if (config.languageKeyCache) {
-            UtilsCache.languageKeyCache = config.languageKeyCache;
+            this.languageKeyCache = config.languageKeyCache;
         }
-        UtilsCommunicateMicro.GetMessage(UtilsCache.typeKeyClearLocalStorage).pipe(filter(e => e.data.response !== UtilsCache.idService)).subscribe(() => {
-            UtilsCache.ClearAll();
-        });
     }
     static setLang(lang) {
-        if (lang !== UtilsLanguageConstants.VI && lang !== UtilsLanguageConstants.EN) {
-            throw Error('Language support vi | en');
+        if (!UtilsLanguageConstants.isSupported(lang)) {
+            throw Error(`Language not support ${lang}`);
         }
-        UtilsCache.language.set(lang);
-        UtilsCache.Set(UtilsCache.languageKeyCache, lang);
+        this.Set(this.languageKeyCache, lang, this.CACHE_EXPIRE_NONE);
     }
     static getLang() {
-        return UtilsCache.language();
+        return this.Get(this.languageKeyCache, UtilsLanguageConstants.defaultLang);
     }
     static openDB() {
         return new Promise(resolve => {
-            const request = indexedDB.open(UtilsCache.dbName, UtilsCache.dbVersion);
+            const request = indexedDB.open(this.dbName, this.dbVersion);
             request.onupgradeneeded = (event) => {
                 const db = event.target.result;
-                if (!db.objectStoreNames.contains(UtilsCache.dbName)) {
-                    const objectStore = db.createObjectStore(UtilsCache.dbName, { keyPath: 'id', autoIncrement: true });
-                    objectStore.createIndex(UtilsCache.itemIndexByKey, UtilsCache.itemIndexByKey, { unique: true });
+                if (!db.objectStoreNames.contains(this.dbName)) {
+                    const objectStore = db.createObjectStore(this.dbName, { keyPath: this.itemIndexByKey });
+                    objectStore.createIndex(this.itemIndexByKey, this.itemIndexByKey, { unique: true });
                 }
             };
             request.onsuccess = () => {
-                UtilsCache.db = request.result;
-                setTimeout(() => {
-                    UtilsCache.DeleteKeyStartWithAsync('');
-                }, 2000);
+                this.db = request.result;
                 resolve(true);
             };
             request.onerror = (event) => {
-                console.error('Error opening IndexedDB:', event);
+                console.trace('Error opening IndexedDB:', event);
                 resolve(false);
             };
         });
     }
     static async getObjectStore() {
-        if (!UtilsCache.db) {
-            await UtilsCache.openDB();
+        if (!this.db) {
+            await this.openDB();
+        }
+        const transaction = this.db?.transaction([this.dbName], 'readwrite');
+        if (!transaction) {
+            return null;
         }
-        const transaction = UtilsCache.db?.transaction([UtilsCache.dbName], 'readwrite');
-        return transaction?.objectStore(UtilsCache.dbName);
+        return transaction.objectStore(this.dbName);
     }
     static get LocalStorage() {
         try {
@@ -95,12 +89,12 @@ export class UtilsCache {
             return this.getLocalStorageFake();
         }
         catch (error) {
-            console.log(error);
+            console.trace(`LocalStorage `, error);
             return this.getLocalStorageFake();
         }
     }
     static getLocalStorageFakeOnSafari() {
-        if (typeof window.localStorage !== 'undefined' && !UtilsCache.storage && Object.keys(localStorage).length) {
+        if (typeof window.localStorage !== 'undefined' && !this.storage && Object.keys(localStorage).length) {
             this.storage = { ...localStorage };
         }
         return {
@@ -130,7 +124,7 @@ export class UtilsCache {
         };
     }
     static getLocalStorageFake() {
-        if (!UtilsCache.storage) {
+        if (!this.storage) {
             this.storage = {};
         }
         return {
@@ -150,19 +144,18 @@ export class UtilsCache {
     }
     static async GetAsync(key, default_value, isKeyMD5 = false) {
         key = isKeyMD5 ? key : md5(key);
-        return new Promise(async (resolve, reject) => {
-            const objectStore = await UtilsCache.getObjectStore();
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
             if (!objectStore) {
                 return resolve(default_value);
             }
-            const index = objectStore.index(UtilsCache.itemIndexByKey);
-            const request = index.get(key);
+            const request = objectStore.get(key);
             request.onsuccess = () => {
                 if (!request.result) {
                     return resolve(default_value);
                 }
                 const data = JSON.parse(decrypt(request.result.value));
-                if (data.expire === UtilsCache.CACHE_EXPIRE_NONE) {
+                if (data.expire === this.CACHE_EXPIRE_NONE) {
                     return resolve(data.json);
                 }
                 const currentMillisecond = (new Date().valueOf() / 1000);
@@ -172,7 +165,8 @@ export class UtilsCache {
                 return resolve(data.json);
             };
             request.onerror = () => {
-                reject(request.error);
+                console.trace(`Get key ${key} Error, return default value: ${default_value}`);
+                return resolve(default_value);
             };
         });
     }
@@ -186,8 +180,8 @@ export class UtilsCache {
         }
         try {
             const data = JSON.parse(decrypt(cachedData));
-            if (data.expire === UtilsCache.CACHE_EXPIRE_NONE) {
-                return data.value;
+            if (data.expire === this.CACHE_EXPIRE_NONE) {
+                return data.value ?? default_value;
             }
             const currentMillisecond = (new Date().valueOf() / 1000);
             if (data.expire < currentMillisecond) {
@@ -196,97 +190,71 @@ export class UtilsCache {
             return data.value;
         }
         catch (error) {
-            console.log(error);
+            console.trace(`Get key ${key} Error, return default value: ${default_value}`, error);
             return this.GetDefaultValueBySpecificKey(key, default_value);
         }
     }
     static GetDefaultValueBySpecificKey(key, default_value) {
         return default_value;
     }
-    static async SetAsync(key, value, expireTimeBySecond = UtilsCache.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false) {
-        return new Promise(async (resolve, reject) => {
-            let objectStore = await UtilsCache.getObjectStore();
+    static async SetAsync(key, value, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false) {
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
             key = isKeyMD5 ? key : md5(key);
             try {
-                const currentMillisecond = expireTimeBySecond === UtilsCache.CACHE_EXPIRE_NONE ? UtilsCache.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
+                const currentMillisecond = expireTimeBySecond === this.CACHE_EXPIRE_NONE ? this.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
                 const data = {
-                    key: key,
                     value: encrypt(JSON.stringify({ json: value, expire: currentMillisecond })),
                 };
+                data[this.itemIndexByKey] = key;
                 if (!objectStore) {
-                    return resolve(-1);
+                    console.trace(`Can not open object store`);
+                    return resolve({ key, messageError: 'Can not open object store' });
                 }
-                const index = objectStore.index(UtilsCache.itemIndexByKey);
-                const getIndexKeyRequest = index.get(key);
-                getIndexKeyRequest.onsuccess = async () => {
-                    const item = getIndexKeyRequest.result;
-                    if (item) {
-                        await UtilsCache.ClearAsync(key, true);
-                        objectStore = await UtilsCache.getObjectStore();
-                    }
-                    if (!objectStore) {
-                        return resolve(-1);
-                    }
-                    const request = objectStore.add(data);
-                    request.onsuccess = () => {
-                        resolve(request.result);
-                    };
-                    request.onerror = () => {
-                        console.log(request.error);
-                        return resolve(-1);
-                    };
+                const request = objectStore?.put(data);
+                request.onsuccess = () => {
+                    console.log(`Set key ${key} Success`);
+                    resolve(request.result);
                 };
-                getIndexKeyRequest.onerror = (event) => {
-                    console.error('Error fetching item by name:', event.target.error);
-                    reject(event.target.error);
+                request.onerror = (error) => {
+                    console.trace(`Set key ${key} Error`);
+                    resolve({ key, messageError: get(error, 'message') });
                 };
             }
             catch (error) {
-                console.log(error);
-                resolve({});
+                console.trace(`Set key ${key} Error`);
+                resolve({ key, messageError: get(error, 'message') });
             }
         });
     }
-    static Set(key, value, expireTimeBySecond = UtilsCache.CACHE_EXPIRE_TIME_DEFAULT) {
-        if (value === undefined || value === null || value === '') {
-            return;
-        }
-        const currentMillisecond = expireTimeBySecond === UtilsCache.CACHE_EXPIRE_NONE ? UtilsCache.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
+    static Set(key, value, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT) {
+        const currentMillisecond = expireTimeBySecond === this.CACHE_EXPIRE_NONE ? this.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
         const data = {
             value: value,
             expire: currentMillisecond
         };
         try {
             this.LocalStorage.setItem(key, encrypt(JSON.stringify(data)));
+            return true;
         }
         catch (error) {
-            console.log(error);
+            console.trace(`Set key ${key} Error`, error);
+            return false;
         }
     }
     static async ClearAsync(key, isMD5 = false) {
         return new Promise(async (resolve) => {
-            const objectStore = await UtilsCache.getObjectStore();
+            const objectStore = await this.getObjectStore();
             if (!objectStore) {
-                return resolve({});
+                return resolve();
             }
-            const index = objectStore.index(UtilsCache.itemIndexByKey);
-            const getRequest = index.get(isMD5 ? key : md5(key));
-            getRequest.onsuccess = () => {
-                const result = getRequest.result;
-                if (result) {
-                    const deleteRequest = objectStore.delete(result.id); // Xóa theo id của item tìm được
-                    deleteRequest.onsuccess = () => {
-                        resolve({});
-                    };
-                    deleteRequest.onerror = () => {
-                        resolve({});
-                    };
-                    return;
-                }
-                resolve({});
+            const request = objectStore.delete(isMD5 ? key : md5(key));
+            request.onsuccess = () => {
+                resolve({ clearSuccess: true });
             };
-            getRequest.onerror = () => {
-                resolve({});
+            request.onerror = (event) => {
+                console.trace('Error deleting Key:', get(event.target.error, 'message'));
+                resolve({ messageError: get(event.target.error, 'message'), clearSuccess: false });
             };
         });
     }
@@ -297,38 +265,41 @@ export class UtilsCache {
         this.LocalStorage.removeItem(key);
     }
     static ClearAllAsync() {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.deleteDatabase(this.dbName);
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve();
+            }
+            const request = objectStore.clear();
             request.onsuccess = () => {
-                console.log('Database deleted successfully');
-                resolve(true);
+                console.log('clear all successfully');
+                resolve({ clearSuccess: true });
             };
             request.onerror = (event) => {
-                console.error('Error deleting database:', event.target.error);
-                reject(event.target.error);
-            };
-            request.onblocked = () => {
-                console.warn('Delete request is blocked');
+                console.trace('Error deleting key:', get(event.target.error, 'message'));
+                resolve({ messageError: get(event.target.error, 'message'), clearSuccess: false });
             };
         });
     }
     static ClearAll() {
-        const keys = [...UtilsCache.listKeyKeepWhenClearALll];
+        if (isEmbedFrame()) {
+            const data = {
+                type: this.typeKeyClearLocalStorage,
+                response: {
+                    idEvent: this.idService
+                }
+            };
+            UtilsCommunicateMicro.PostMessageToParent(data);
+        }
+        const keys = [...this.listKeyKeepWhenClearALll];
         Object.keys(this.LocalStorage).forEach(key => {
             if (key.includes('kc-callback-')) {
                 keys.push(key);
             }
         });
-        const stores = UtilsCache.GetDataByKeys(Array.from(keys));
+        const stores = this.GetDataByKeys(Array.from(keys));
         this.LocalStorage.clear();
-        UtilsCache.SetDataByKey(stores);
-        const data = {
-            type: UtilsCache.typeKeyClearLocalStorage,
-            response: {
-                idEvent: this.idService
-            }
-        };
-        UtilsCommunicateMicro.PostMessageToParent(data);
+        this.SetDataByKey(stores);
     }
     static GetDataByKeys(keys) {
         const stores = new Map();
@@ -337,7 +308,7 @@ export class UtilsCache {
                 stores.set(key, this.LocalStorage.getItem(key));
                 return;
             }
-            stores.set(key, UtilsCache.Get(key));
+            stores.set(key, this.Get(key));
         });
         return stores;
     }
@@ -347,21 +318,20 @@ export class UtilsCache {
                 this.LocalStorage.setItem(key, value);
                 return;
             }
-            if (key === UtilsCache.languageKeyCache) {
-                return UtilsCache.setLang(value);
+            if (key === this.languageKeyCache) {
+                return this.setLang(value);
             }
-            UtilsCache.Set(key, value, UtilsCache.CACHE_EXPIRE_NONE);
+            this.Set(key, value, this.CACHE_EXPIRE_NONE);
         });
     }
     static DeleteKeyStartWithAsync(keyCacheStartWith, isKeyMD5 = false) {
         return new Promise(async (resolve) => {
-            const objectStore = await UtilsCache.getObjectStore();
+            const objectStore = await this.getObjectStore();
             if (!objectStore) {
                 return resolve({});
             }
-            const index = objectStore.index(UtilsCache.itemIndexByKey);
             // Lấy tất cả các keys từ index
-            const request = index.getAll();
+            const request = objectStore.getAll();
             keyCacheStartWith = isKeyMD5 ? keyCacheStartWith : md5(keyCacheStartWith);
             request.onsuccess = (e) => {
                 const data = e.target.result;
@@ -369,8 +339,8 @@ export class UtilsCache {
                     return resolve({});
                 }
                 data.forEach(obj => {
-                    if (obj.key.startsWith(keyCacheStartWith)) {
-                        UtilsCache.ClearAsync(obj.key, true);
+                    if (obj[this.itemIndexByKey].startsWith(keyCacheStartWith)) {
+                        this.ClearAsync(obj[this.itemIndexByKey], true);
                     }
                 });
                 return resolve({});
@@ -382,7 +352,7 @@ export class UtilsCache {
     }
     static DeleteKeyStartWith(keyCache, isMD5 = false) {
         keyCache = isMD5 ? md5(keyCache) : keyCache;
-        const keys = Object.keys(UtilsCache.LocalStorage);
+        const keys = Object.keys(this.LocalStorage);
         if (!keys || !keys.length) {
             return;
         }
@@ -392,5 +362,24 @@ export class UtilsCache {
             }
         });
     }
+    static DeleteDatabaseIndexDB(dbName) {
+        return new Promise((resolve) => {
+            dbName = (dbName || this.dbName);
+            const request = indexedDB.deleteDatabase(dbName);
+            request.onsuccess = () => {
+                console.trace('Database deleted successfully');
+                resolve({ deleteSuccess: true });
+            };
+            request.onerror = (event) => {
+                const error = event.target.error;
+                console.trace('Error deleting database:', error);
+                resolve({ messageError: get(error || {}, 'message'), deleteSuccess: false });
+            };
+            request.onblocked = () => {
+                console.trace('Delete request is blocked');
+                resolve({ messageError: 'Delete request is blocked', deleteSuccess: false });
+            };
+        });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../../libs-ui/utils/src/cache.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-async-promise-executor */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { signal } from '@angular/core';\nimport { filter } from 'rxjs';\nimport { UtilsCommunicateMicro } from './communicate-micro';\nimport { decrypt, encrypt, md5 } from './crypto';\nimport { getPlatFromBrowser } from './dom';\nimport { isNil } from './helpers';\nimport { UtilsLanguageConstants } from './language';\nimport { uuid } from './uuid';\n\nexport class UtilsCache {\n\n  public static readonly CACHE_EXPIRE_NONE = -1;\n\n  private static typeKeyClearLocalStorage = 'LIBS_UI_CLEAR_LOCAL_STORAGE_EVENT';\n  private static listKeyKeepWhenClearALll = Array<string>();\n  private static languageKeyCache = 'SR3xQKxHgffiCevPQRralg';\n  private static initdEvent?: boolean;\n  private static readonly CACHE_EXPIRE_TIME_DEFAULT = 5 * 60;\n  private static language = signal<string>(UtilsLanguageConstants.defaultLang);\n  private static idService = uuid();\n  private static storage: { [key: string]: unknown };\n  private static dbName = 'libs-ui-cache';\n  private static itemIndexByKey = 'key';\n  private static dbVersion = 1;\n  private static db: IDBDatabase | null = null;\n\n  public static init(config: { indexedDBName?: string, languageKeyCache?: string, typeKeyClearLocalStorage?: string, listKeyKeepWhenClearALll?: Array<string> }) {\n    if (UtilsCache.initdEvent) {\n      return;\n    }\n    UtilsCache.initdEvent = true;\n    if (config.indexedDBName) {\n      UtilsCache.dbName = config.indexedDBName;\n    }\n    if (config.typeKeyClearLocalStorage) {\n      UtilsCache.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;\n    }\n    if (config.listKeyKeepWhenClearALll) {\n      UtilsCache.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearALll;\n    }\n    if (config.languageKeyCache) {\n      UtilsCache.languageKeyCache = config.languageKeyCache;\n    }\n    UtilsCommunicateMicro.GetMessage(UtilsCache.typeKeyClearLocalStorage).pipe(filter(e => e.data.response !== UtilsCache.idService)).subscribe(() => {\n      UtilsCache.ClearAll();\n    });\n  }\n\n  public static setLang(lang: string) {\n    if (lang !== UtilsLanguageConstants.VI && lang !== UtilsLanguageConstants.EN) {\n      throw Error('Language support vi | en');\n    }\n    UtilsCache.language.set(lang);\n    UtilsCache.Set(UtilsCache.languageKeyCache, lang);\n  }\n\n  public static getLang() {\n    return UtilsCache.language();\n  }\n\n  private static openDB() {\n    return new Promise(resolve => {\n      const request = indexedDB.open(UtilsCache.dbName, UtilsCache.dbVersion);\n\n      request.onupgradeneeded = (event: IDBVersionChangeEvent) => {\n        const db = (event.target as IDBOpenDBRequest).result;\n\n        if (!db.objectStoreNames.contains(UtilsCache.dbName)) {\n          const objectStore = db.createObjectStore(UtilsCache.dbName, { keyPath: 'id', autoIncrement: true });\n\n          objectStore.createIndex(UtilsCache.itemIndexByKey, UtilsCache.itemIndexByKey, { unique: true });\n        }\n      };\n\n      request.onsuccess = () => {\n        UtilsCache.db = request.result;\n        setTimeout(() => {\n          UtilsCache.DeleteKeyStartWithAsync('');\n        }, 2000);\n        resolve(true);\n      };\n\n      request.onerror = (event) => {\n        console.error('Error opening IndexedDB:', event);\n        resolve(false);\n      };\n    });\n  }\n\n  private static async getObjectStore() {\n    if (!UtilsCache.db) {\n      await UtilsCache.openDB();\n    }\n    const transaction = UtilsCache.db?.transaction([UtilsCache.dbName], 'readwrite');\n\n    return transaction?.objectStore(UtilsCache.dbName);\n  }\n\n  private static get LocalStorage(): any {\n    try {\n      if (typeof window.localStorage !== 'undefined') {\n        const OS = getPlatFromBrowser();\n\n        if (OS.includes('Safari') && parseFloat(OS.split(' ').pop() || '0') >= 16) {\n\n          return this.getLocalStorageFakeOnSafari();\n        }\n\n        return localStorage;\n      }\n\n      return this.getLocalStorageFake();\n    } catch (error) {\n      console.log(error);\n      return this.getLocalStorageFake();\n    }\n  }\n\n  private static getLocalStorageFakeOnSafari() {\n    if (typeof window.localStorage !== 'undefined' && !UtilsCache.storage && Object.keys(localStorage).length) {\n      this.storage = { ...localStorage };\n    }\n\n    return {\n      setItem: (key: string, value: string) => {\n        localStorage.setItem(key, value);\n        this.storage[key] = value;\n      },\n      getItem: (key: string) => {\n        const value = localStorage.getItem(key);\n\n        if (value) {\n          return value;\n        }\n\n        if (!this.storage || isNil(this.storage[key])) {\n          return null;\n        }\n\n        localStorage.setItem(key, this.storage[key] as string);\n\n        return this.storage?.[key];\n      },\n      removeItem: (key: string) => {\n        delete this.storage?.[key];\n        localStorage.removeItem(key);\n      },\n      clear: () => {\n        this.storage = {};\n        localStorage.clear();\n      }\n    };\n  }\n\n  private static getLocalStorageFake() {\n    if (!UtilsCache.storage) {\n      this.storage = {};\n    }\n\n    return {\n      setItem: (key: string, value: unknown) => {\n        this.storage[key] = value;\n      },\n      getItem: (key: string) => {\n        return this.storage?.[key];\n      },\n      removeItem: (key: string) => {\n        delete this.storage?.[key];\n      },\n      clear: () => {\n        this.storage = {};\n      }\n    };\n  }\n\n  public static async GetAsync(key: string, default_value?: any, isKeyMD5 = false) {\n    key = isKeyMD5 ? key : md5(key);\n\n    return new Promise<any>(async (resolve, reject) => {\n      const objectStore = await UtilsCache.getObjectStore();\n\n      if (!objectStore) {\n\n        return resolve(default_value);\n      }\n      const index = objectStore.index(UtilsCache.itemIndexByKey);\n      const request = index.get(key);\n\n      request.onsuccess = () => {\n        if (!request.result) {\n          return resolve(default_value);\n        }\n        const data = JSON.parse(decrypt(request.result.value));\n\n        if (data.expire === UtilsCache.CACHE_EXPIRE_NONE) {\n          return resolve(data.json);\n        }\n        const currentMillisecond = (new Date().valueOf() / 1000);\n\n        if (data.expire < currentMillisecond) {\n\n          return resolve(default_value);\n        }\n\n        return resolve(data.json);\n      };\n\n      request.onerror = () => {\n        reject(request.error);\n      };\n    });\n  }\n\n  public static Get(key: string, default_value?: any) { // support cho những file không thể inject UtilsCache\n    if (!key) {\n      return this.GetDefaultValueBySpecificKey(key, default_value);\n    }\n    const cachedData = this.LocalStorage.getItem(key);\n\n    if (!cachedData) {\n      return this.GetDefaultValueBySpecificKey(key, default_value);\n    }\n    try {\n      const data = JSON.parse(decrypt(cachedData));\n\n      if (data.expire === UtilsCache.CACHE_EXPIRE_NONE) {\n        return data.value;\n      }\n      const currentMillisecond = (new Date().valueOf() / 1000);\n\n      if (data.expire < currentMillisecond) {\n        return this.GetDefaultValueBySpecificKey(key, default_value);\n      }\n\n      return data.value;\n\n    } catch (error) {\n      console.log(error);\n\n      return this.GetDefaultValueBySpecificKey(key, default_value);\n    }\n  }\n\n  private static GetDefaultValueBySpecificKey(key: string, default_value: any) {\n    return default_value;\n\n  }\n\n  public static async SetAsync(key: string, value: any, expireTimeBySecond = UtilsCache.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false) { // support inject UtilsCache\n    return new Promise(async (resolve, reject) => {\n      let objectStore = await UtilsCache.getObjectStore();\n\n      key = isKeyMD5 ? key : md5(key);\n      try {\n        const currentMillisecond = expireTimeBySecond === UtilsCache.CACHE_EXPIRE_NONE ? UtilsCache.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;\n        const data = {\n          key: key,\n          value: encrypt(JSON.stringify({ json: value, expire: currentMillisecond })),\n        };\n\n        if (!objectStore) {\n          return resolve(-1);\n        }\n        const index = objectStore.index(UtilsCache.itemIndexByKey);\n        const getIndexKeyRequest = index.get(key);\n\n        getIndexKeyRequest.onsuccess = async () => {\n          const item = getIndexKeyRequest.result;\n\n          if (item) {\n            await UtilsCache.ClearAsync(key, true);\n            objectStore = await UtilsCache.getObjectStore();\n          }\n\n          if (!objectStore) {\n            return resolve(-1);\n          }\n          const request = objectStore.add(data);\n\n          request.onsuccess = () => {\n            resolve(request.result);\n          };\n\n          request.onerror = () => {\n            console.log(request.error);\n\n            return resolve(-1);\n          };\n        };\n\n        getIndexKeyRequest.onerror = (event: Event) => {\n          console.error('Error fetching item by name:', (event.target as IDBRequest).error);\n          reject((event.target as IDBRequest).error);\n        };\n      } catch (error) {\n        console.log(error);\n        resolve({});\n      }\n    });\n  }\n\n\n  static Set(key: string, value: any, expireTimeBySecond = UtilsCache.CACHE_EXPIRE_TIME_DEFAULT) { // support cho những file không inject UtilsCache\n    if (value === undefined || value === null || value === '') {\n      return;\n    }\n    const currentMillisecond = expireTimeBySecond === UtilsCache.CACHE_EXPIRE_NONE ? UtilsCache.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;\n    const data = {\n      value: value,\n      expire: currentMillisecond\n    };\n\n    try {\n      this.LocalStorage.setItem(key, encrypt(JSON.stringify(data)));\n    } catch (error) {\n      console.log(error);\n    }\n  }\n\n  public static async ClearAsync(key: string, isMD5 = false) {\n    return new Promise(async (resolve) => {\n      const objectStore = await UtilsCache.getObjectStore();\n\n      if (!objectStore) {\n        return resolve({});\n      }\n      const index = objectStore.index(UtilsCache.itemIndexByKey);\n\n      const getRequest = index.get(isMD5 ? key : md5(key));\n\n      getRequest.onsuccess = () => {\n        const result = getRequest.result;\n\n        if (result) {\n          const deleteRequest = objectStore.delete(result.id); // Xóa theo id của item tìm được\n\n          deleteRequest.onsuccess = () => {\n            resolve({});\n          };\n          deleteRequest.onerror = () => {\n            resolve({});\n          };\n\n          return;\n        }\n        resolve({});\n      };\n\n      getRequest.onerror = () => {\n        resolve({});\n      };\n    });\n  }\n\n  static Clear(key: string) {\n    if (key.includes('kc-callback-')) {\n      return;\n    }\n    this.LocalStorage.removeItem(key);\n  }\n\n  public static ClearAllAsync() {\n    return new Promise((resolve, reject) => {\n      const request = indexedDB.deleteDatabase(this.dbName);\n\n      request.onsuccess = () => {\n        console.log('Database deleted successfully');\n        resolve(true);\n      };\n\n      request.onerror = (event: Event) => {\n        console.error('Error deleting database:', (event.target as IDBRequest).error);\n        reject((event.target as IDBRequest).error);\n      };\n\n      request.onblocked = () => {\n        console.warn('Delete request is blocked');\n      };\n    });\n  }\n\n  static ClearAll() {\n    const keys = [...UtilsCache.listKeyKeepWhenClearALll];\n    Object.keys(this.LocalStorage).forEach(key => {\n      if (key.includes('kc-callback-')) {\n        keys.push(key);\n      }\n    });\n\n    const stores = UtilsCache.GetDataByKeys(Array.from(keys));\n\n    this.LocalStorage.clear();\n\n    UtilsCache.SetDataByKey(stores);\n    const data = {\n      type: UtilsCache.typeKeyClearLocalStorage,\n      response: {\n        idEvent: this.idService\n      }\n    };\n\n    UtilsCommunicateMicro.PostMessageToParent(data);\n  }\n\n  private static GetDataByKeys(keys: Array<string>) {\n    const stores = new Map();\n\n    keys.forEach((key: string) => {\n      if (key.includes('kc-callback-')) {\n        stores.set(key, this.LocalStorage.getItem(key));\n\n        return;\n      }\n      stores.set(key, UtilsCache.Get(key));\n    });\n\n    return stores;\n  }\n\n  private static SetDataByKey(stores: Map<string, any>) {\n    stores.forEach((value: any, key: string) => {\n      if (key.includes('kc-callback-')) {\n        this.LocalStorage.setItem(key, value);\n\n        return;\n      }\n      if (key === UtilsCache.languageKeyCache) {\n        return UtilsCache.setLang(value);\n      }\n      UtilsCache.Set(key, value, UtilsCache.CACHE_EXPIRE_NONE);\n    });\n  }\n\n  public static DeleteKeyStartWithAsync(keyCacheStartWith: string, isKeyMD5 = false) {\n    return new Promise(async (resolve) => {\n      const objectStore = await UtilsCache.getObjectStore();\n\n      if (!objectStore) {\n        return resolve({});\n      }\n      const index = objectStore.index(UtilsCache.itemIndexByKey);\n\n      // Lấy tất cả các keys từ index\n      const request = index.getAll();\n\n      keyCacheStartWith = isKeyMD5 ? keyCacheStartWith : md5(keyCacheStartWith);\n\n\n      request.onsuccess = (e: any) => {\n        const data = e.target.result as Array<any>;\n\n        if (!Array.isArray(data)) {\n          return resolve({});\n        }\n\n        data.forEach(obj => {\n          if (obj.key.startsWith(keyCacheStartWith)) {\n            UtilsCache.ClearAsync(obj.key, true);\n          }\n        });\n\n        return resolve({});\n      };\n\n      request.onerror = () => {\n        return resolve({});\n      };\n    });\n  }\n\n  public static DeleteKeyStartWith(keyCache: string, isMD5 = false) {\n    keyCache = isMD5 ? md5(keyCache) : keyCache;\n    const keys = Object.keys(UtilsCache.LocalStorage);\n\n    if (!keys || !keys.length) {\n      return;\n    }\n\n    keys.forEach(key => {\n      if (key.startsWith(keyCache)) {\n        this.Clear(key);\n      }\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../../libs-ui/utils/src/cache.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-async-promise-executor */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { IEvent, TYPE_LANGUAGE_SUPPORT } from '@libs-ui/interfaces-types';\nimport { UtilsCommunicateMicro } from './communicate-micro';\nimport { decrypt, encrypt, md5 } from './crypto';\nimport { getPlatFromBrowser } from './dom';\nimport { isEmbedFrame } from './function-check-embed-frame';\nimport { get, isNil } from './helpers';\nimport { UtilsLanguageConstants } from './language';\nimport { uuid } from './uuid';\n\nexport class UtilsCache {\n  public static readonly CACHE_EXPIRE_TIME_DEFAULT = 5 * 60;\n  public static readonly CACHE_EXPIRE_NONE = -1;\n  public static readonly idService = uuid();\n  public static typeKeyClearLocalStorage = 'LIBS_UI_CLEAR_LOCAL_STORAGE_EVENT';\n\n  private static languageKeyCache = 'SR3xQKxHgffiCevPQRralg';\n  private static listKeyKeepWhenClearALll = Array<string>();\n  private static initdEvent?: boolean;\n  private static storage: { [key: string]: unknown };\n  private static dbName = 'libs-ui-cache';\n  private static itemIndexByKey = 'key';\n  private static dbVersion = 1;\n  private static db: IDBDatabase | null = null;\n\n  public static init(config: { indexedDBName?: string, languageKeyCache?: string, typeKeyClearLocalStorage?: string, listKeyKeepWhenClearAll?: Array<string> }) {\n    if (this.initdEvent) {\n      return;\n    }\n    this.initdEvent = true;\n    if (config.indexedDBName) {\n      this.dbName = config.indexedDBName;\n    }\n    if (config.typeKeyClearLocalStorage) {\n      this.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;\n    }\n    if (config.listKeyKeepWhenClearAll) {\n      this.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearAll;\n    }\n    if (config.languageKeyCache) {\n      this.languageKeyCache = config.languageKeyCache;\n    }\n  }\n\n  public static setLang(lang: TYPE_LANGUAGE_SUPPORT) {\n    if (!UtilsLanguageConstants.isSupported(lang)) {\n      throw Error(`Language not support ${lang}`);\n    }\n    this.Set(this.languageKeyCache, lang, this.CACHE_EXPIRE_NONE);\n  }\n\n  public static getLang(): TYPE_LANGUAGE_SUPPORT {\n    return this.Get(this.languageKeyCache, UtilsLanguageConstants.defaultLang);\n  }\n\n  private static openDB() {\n    return new Promise(resolve => {\n      const request = indexedDB.open(this.dbName, this.dbVersion);\n\n      request.onupgradeneeded = (event: IDBVersionChangeEvent) => {\n        const db = (event.target as IDBOpenDBRequest).result;\n\n        if (!db.objectStoreNames.contains(this.dbName)) {\n          const objectStore = db.createObjectStore(this.dbName, { keyPath: this.itemIndexByKey });\n\n          objectStore.createIndex(this.itemIndexByKey, this.itemIndexByKey, { unique: true });\n        }\n      };\n\n      request.onsuccess = () => {\n        this.db = request.result;\n        resolve(true);\n      };\n\n      request.onerror = (event) => {\n        console.trace('Error opening IndexedDB:', event);\n        resolve(false);\n      };\n    });\n  }\n\n  private static async getObjectStore() {\n    if (!this.db) {\n      await this.openDB();\n    }\n    const transaction = this.db?.transaction([this.dbName], 'readwrite');\n    if (!transaction) {\n      return null;\n    }\n\n    return transaction.objectStore(this.dbName);\n  }\n\n  private static get LocalStorage(): any {\n    try {\n      if (typeof window.localStorage !== 'undefined') {\n        const OS = getPlatFromBrowser();\n\n        if (OS.includes('Safari') && parseFloat(OS.split(' ').pop() || '0') >= 16) {\n\n          return this.getLocalStorageFakeOnSafari();\n        }\n\n        return localStorage;\n      }\n\n      return this.getLocalStorageFake();\n    } catch (error) {\n      console.trace(`LocalStorage `, error);\n      return this.getLocalStorageFake();\n    }\n  }\n\n  private static getLocalStorageFakeOnSafari() {\n    if (typeof window.localStorage !== 'undefined' && !this.storage && Object.keys(localStorage).length) {\n      this.storage = { ...localStorage };\n    }\n\n    return {\n      setItem: (key: string, value: string) => {\n        localStorage.setItem(key, value);\n        this.storage[key] = value;\n      },\n      getItem: (key: string) => {\n        const value = localStorage.getItem(key);\n\n        if (value) {\n          return value;\n        }\n\n        if (!this.storage || isNil(this.storage[key])) {\n          return null;\n        }\n\n        localStorage.setItem(key, this.storage[key] as string);\n\n        return this.storage?.[key];\n      },\n      removeItem: (key: string) => {\n        delete this.storage?.[key];\n        localStorage.removeItem(key);\n      },\n      clear: () => {\n        this.storage = {};\n        localStorage.clear();\n      }\n    };\n  }\n\n  private static getLocalStorageFake() {\n    if (!this.storage) {\n      this.storage = {};\n    }\n\n    return {\n      setItem: (key: string, value: unknown) => {\n        this.storage[key] = value;\n      },\n      getItem: (key: string) => {\n        return this.storage?.[key];\n      },\n      removeItem: (key: string) => {\n        delete this.storage?.[key];\n      },\n      clear: () => {\n        this.storage = {};\n      }\n    };\n  }\n\n  public static async GetAsync<T = any>(key: string, default_value?: any, isKeyMD5 = false): Promise<T> {\n    key = isKeyMD5 ? key : md5(key);\n\n    return new Promise<T>(async (resolve) => {\n      const objectStore = await this.getObjectStore();\n\n      if (!objectStore) {\n\n        return resolve(default_value);\n      }\n      const request = objectStore.get(key);\n\n      request.onsuccess = () => {\n        if (!request.result) {\n          return resolve(default_value);\n        }\n        const data = JSON.parse(decrypt(request.result.value));\n\n        if (data.expire === this.CACHE_EXPIRE_NONE) {\n          return resolve(data.json);\n        }\n        const currentMillisecond = (new Date().valueOf() / 1000);\n\n        if (data.expire < currentMillisecond) {\n\n          return resolve(default_value);\n        }\n\n        return resolve(data.json);\n      };\n\n      request.onerror = () => {\n        console.trace(`Get key ${key} Error, return default value: ${default_value}`);\n        return resolve(default_value);\n      };\n    });\n  }\n\n  public static Get<T = any>(key: string, default_value?: any): T { // support cho những file không thể inject UtilsCache\n    if (!key) {\n      return this.GetDefaultValueBySpecificKey(key, default_value);\n    }\n    const cachedData = this.LocalStorage.getItem(key);\n\n    if (!cachedData) {\n      return this.GetDefaultValueBySpecificKey(key, default_value);\n    }\n    try {\n      const data = JSON.parse(decrypt(cachedData));\n\n      if (data.expire === this.CACHE_EXPIRE_NONE) {\n        return data.value ?? default_value;\n      }\n      const currentMillisecond = (new Date().valueOf() / 1000);\n\n      if (data.expire < currentMillisecond) {\n        return this.GetDefaultValueBySpecificKey(key, default_value);\n      }\n\n      return data.value;\n\n    } catch (error) {\n      console.trace(`Get key ${key} Error, return default value: ${default_value}`, error);\n\n      return this.GetDefaultValueBySpecificKey(key, default_value);\n    }\n  }\n\n  public static GetDefaultValueBySpecificKey(key: string, default_value: any) {\n    return default_value;\n\n  }\n\n  public static async SetAsync<T = any>(key: string, value: any, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false): Promise<T> { // support inject UtilsCache\n    return new Promise<T>(async (resolve) => {\n      const objectStore = await this.getObjectStore();\n\n      key = isKeyMD5 ? key : md5(key);\n      try {\n        const currentMillisecond = expireTimeBySecond === this.CACHE_EXPIRE_NONE ? this.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;\n        const data: any = {\n          value: encrypt(JSON.stringify({ json: value, expire: currentMillisecond })),\n        };\n        data[this.itemIndexByKey] = key;\n\n        if (!objectStore) {\n          console.trace(`Can not open object store`);\n          return resolve({ key, messageError: 'Can not open object store' } as any);\n        }\n        const request = objectStore?.put(data);\n        request.onsuccess = () => {\n          console.log(`Set key ${key} Success`);\n          resolve(request.result as any);\n        };\n\n        request.onerror = (error) => {\n          console.trace(`Set key ${key} Error`);\n          resolve({ key, messageError: get(error as IEvent, 'message') } as any);\n        };\n\n      } catch (error) {\n        console.trace(`Set key ${key} Error`);\n        resolve({ key, messageError: get(error, 'message') } as any);\n      }\n    });\n  }\n\n\n  static Set(key: string, value: any, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT): boolean { // support cho những file không inject UtilsCache\n    const currentMillisecond = expireTimeBySecond === this.CACHE_EXPIRE_NONE ? this.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;\n    const data = {\n      value: value,\n      expire: currentMillisecond\n    };\n\n    try {\n      this.LocalStorage.setItem(key, encrypt(JSON.stringify(data)));\n      return true;\n    } catch (error) {\n      console.trace(`Set key ${key} Error`, error);\n      return false;\n    }\n  }\n\n  public static async ClearAsync(key: string, isMD5 = false) {\n    return new Promise<void>(async (resolve) => {\n      const objectStore = await this.getObjectStore();\n\n      if (!objectStore) {\n        return resolve();\n      }\n      const request = objectStore.delete(isMD5 ? key : md5(key));\n\n      request.onsuccess = () => {\n        resolve({ clearSuccess: true } as any);\n      };\n      request.onerror = (event: Event) => {\n        console.trace('Error deleting Key:', get((event.target as IDBRequest).error, 'message'));\n        resolve({ messageError: get((event.target as IDBRequest).error, 'message'), clearSuccess: false } as any);\n      };\n    });\n  }\n\n  static Clear(key: string) {\n    if (key.includes('kc-callback-')) {\n      return;\n    }\n    this.LocalStorage.removeItem(key);\n  }\n\n  public static ClearAllAsync() {\n    return new Promise<void>(async (resolve) => {\n      const objectStore = await this.getObjectStore();\n\n      if (!objectStore) {\n        return resolve();\n      }\n\n      const request = objectStore.clear();\n      request.onsuccess = () => {\n        console.log('clear all successfully');\n        resolve({ clearSuccess: true } as any);\n      };\n\n      request.onerror = (event: Event) => {\n        console.trace('Error deleting key:', get((event.target as IDBRequest).error, 'message'));\n        resolve({ messageError: get((event.target as IDBRequest).error, 'message'), clearSuccess: false } as any);\n      };\n    });\n  }\n\n  static ClearAll() {\n    if (isEmbedFrame()) {\n      const data = {\n        type: this.typeKeyClearLocalStorage,\n        response: {\n          idEvent: this.idService\n        }\n      };\n      UtilsCommunicateMicro.PostMessageToParent(data);\n    }\n    const keys = [...this.listKeyKeepWhenClearALll];\n    Object.keys(this.LocalStorage).forEach(key => {\n      if (key.includes('kc-callback-')) {\n        keys.push(key);\n      }\n    });\n\n    const stores = this.GetDataByKeys(Array.from(keys));\n\n    this.LocalStorage.clear();\n\n    this.SetDataByKey(stores);\n  }\n\n  private static GetDataByKeys(keys: Array<string>) {\n    const stores = new Map();\n\n    keys.forEach((key: string) => {\n      if (key.includes('kc-callback-')) {\n        stores.set(key, this.LocalStorage.getItem(key));\n\n        return;\n      }\n      stores.set(key, this.Get(key));\n    });\n\n    return stores;\n  }\n\n  private static SetDataByKey(stores: Map<string, any>) {\n    stores.forEach((value: any, key: string) => {\n      if (key.includes('kc-callback-')) {\n        this.LocalStorage.setItem(key, value);\n\n        return;\n      }\n      if (key === this.languageKeyCache) {\n        return this.setLang(value);\n      }\n      this.Set(key, value, this.CACHE_EXPIRE_NONE);\n    });\n  }\n\n  public static DeleteKeyStartWithAsync(keyCacheStartWith: string, isKeyMD5 = false) {\n    return new Promise(async (resolve) => {\n      const objectStore = await this.getObjectStore();\n\n      if (!objectStore) {\n        return resolve({});\n      }\n\n      // Lấy tất cả các keys từ index\n      const request = objectStore.getAll();\n\n      keyCacheStartWith = isKeyMD5 ? keyCacheStartWith : md5(keyCacheStartWith);\n\n\n      request.onsuccess = (e: any) => {\n        const data = e.target.result as Array<any>;\n\n        if (!Array.isArray(data)) {\n          return resolve({});\n        }\n\n        data.forEach(obj => {\n          if (obj[this.itemIndexByKey].startsWith(keyCacheStartWith)) {\n            this.ClearAsync(obj[this.itemIndexByKey], true);\n          }\n        });\n\n        return resolve({});\n      };\n\n      request.onerror = () => {\n        return resolve({});\n      };\n    });\n  }\n\n  public static DeleteKeyStartWith(keyCache: string, isMD5 = false) {\n    keyCache = isMD5 ? md5(keyCache) : keyCache;\n    const keys = Object.keys(this.LocalStorage);\n\n    if (!keys || !keys.length) {\n      return;\n    }\n\n    keys.forEach(key => {\n      if (key.startsWith(keyCache)) {\n        this.Clear(key);\n      }\n    });\n  }\n\n  public static DeleteDatabaseIndexDB(dbName?: string) {\n    return new Promise((resolve) => {\n      dbName = (dbName || this.dbName) as string;\n      const request = indexedDB.deleteDatabase(dbName as string);\n\n      request.onsuccess = () => {\n        console.trace('Database deleted successfully');\n        resolve({ deleteSuccess: true });\n      };\n\n      request.onerror = (event: Event) => {\n        const error = (event.target as IDBRequest).error;\n        console.trace('Error deleting database:', error);\n        resolve({ messageError: get(error as Record<string, any> || {}, 'message'), deleteSuccess: false } as any);\n      };\n\n      request.onblocked = () => {\n        console.trace('Delete request is blocked');\n        resolve({ messageError: 'Delete request is blocked', deleteSuccess: false } as any);\n      }\n\n    });\n  }\n}\n"]}