@libs-ui/utils 0.2.110 → 0.2.112

package/fesm2022/libs-ui-utils.mjs

@@ -999,61 +999,61 @@ class UtilsCache {
     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.listKeyKeepWhenClearAll) {
-            UtilsCache.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearAll;
+            this.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearAll;
         }
         if (config.languageKeyCache) {
-            UtilsCache.languageKeyCache = config.languageKeyCache;
+            this.languageKeyCache = config.languageKeyCache;
         }
     }
     static setLang(lang) {
         if (lang !== UtilsLanguageConstants.VI && lang !== UtilsLanguageConstants.EN) {
             throw Error('Language support vi | en');
         }
-        UtilsCache.Set(UtilsCache.languageKeyCache, lang, UtilsCache.CACHE_EXPIRE_NONE);
+        this.Set(this.languageKeyCache, lang, this.CACHE_EXPIRE_NONE);
     }
     static getLang() {
-        return UtilsCache.Get(UtilsCache.languageKeyCache, UtilsLanguageConstants.defaultLang);
+        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: UtilsCache.itemIndexByKey, 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;
+                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 = UtilsCache.db?.transaction([UtilsCache.dbName], 'readwrite');
+        const transaction = this.db?.transaction([this.dbName], 'readwrite');
         if (!transaction) {
             return null;
         }
-        return transaction.objectStore(UtilsCache.dbName);
+        return transaction.objectStore(this.dbName);
     }
     static get LocalStorage() {
         try {
@@ -1067,12 +1067,12 @@ class UtilsCache {
             return this.getLocalStorageFake();
         }
         catch (error) {
-            console.log(error);
+            console.trace(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 {
@@ -1102,7 +1102,7 @@ class UtilsCache {
         };
     }
     static getLocalStorageFake() {
-        if (!UtilsCache.storage) {
+        if (!this.storage) {
             this.storage = {};
         }
         return {
@@ -1123,7 +1123,7 @@ 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();
+            const objectStore = await this.getObjectStore();
             if (!objectStore) {
                 return resolve(default_value);
             }
@@ -1133,7 +1133,7 @@ class UtilsCache {
                     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);
@@ -1157,7 +1157,7 @@ class UtilsCache {
         }
         try {
             const data = JSON.parse(decrypt(cachedData));
-            if (data.expire === UtilsCache.CACHE_EXPIRE_NONE) {
+            if (data.expire === this.CACHE_EXPIRE_NONE) {
                 return data.value ?? default_value;
             }
             const currentMillisecond = (new Date().valueOf() / 1000);
@@ -1167,42 +1167,44 @@ class UtilsCache {
             return data.value;
         }
         catch (error) {
-            console.log(error);
+            console.trace(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) {
+    static async SetAsync(key, value, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false) {
         return new Promise(async (resolve, reject) => {
-            const objectStore = await UtilsCache.getObjectStore();
+            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 = {
                     value: encrypt(JSON.stringify({ json: value, expire: currentMillisecond })),
                 };
-                data[UtilsCache.itemIndexByKey] = key;
+                data[this.itemIndexByKey] = key;
                 if (!objectStore) {
                     return reject(new Error('Can not open object store'));
                 }
                 const request = objectStore?.put(data);
                 request.onsuccess = () => {
+                    console.log(`Set key ${key} Success`);
                     resolve(request.result);
                 };
-                request.onerror = () => {
-                    reject(request.error);
+                request.onerror = (error) => {
+                    console.trace(`Set key ${key} Error`);
+                    resolve({ key, messageError: get(error, 'message') });
                 };
             }
             catch (error) {
-                console.log(error);
+                console.trace(`Set key ${key} Error`);
                 resolve({ key, messageError: get(error, 'message') });
             }
         });
     }
-    static Set(key, value, expireTimeBySecond = UtilsCache.CACHE_EXPIRE_TIME_DEFAULT) {
-        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
@@ -1212,13 +1214,13 @@ class UtilsCache {
             return true;
         }
         catch (error) {
-            console.log(error);
+            console.trace(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();
             }
@@ -1239,17 +1241,17 @@ class UtilsCache {
     }
     static ClearAllAsync() {
         return new Promise(async (resolve, reject) => {
-            const objectStore = await UtilsCache.getObjectStore();
+            const objectStore = await this.getObjectStore();
             if (!objectStore) {
                 return resolve();
             }
             const request = objectStore.clear();
             request.onsuccess = () => {
-                console.log('Database deleted successfully');
+                console.log('clear all successfully');
                 resolve();
             };
             request.onerror = (event) => {
-                console.error('Error deleting database:', event.target.error);
+                console.trace('Error deleting database:', event.target.error);
                 reject(event.target.error);
             };
         });
@@ -1257,22 +1259,22 @@ class UtilsCache {
     static ClearAll() {
         if (isEmbedFrame()) {
             const data = {
-                type: UtilsCache.typeKeyClearLocalStorage,
+                type: this.typeKeyClearLocalStorage,
                 response: {
                     idEvent: this.idService
                 }
             };
             UtilsCommunicateMicro.PostMessageToParent(data);
         }
-        const keys = [...UtilsCache.listKeyKeepWhenClearALll];
+        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);
+        this.SetDataByKey(stores);
     }
     static GetDataByKeys(keys) {
         const stores = new Map();
@@ -1281,7 +1283,7 @@ class UtilsCache {
                 stores.set(key, this.LocalStorage.getItem(key));
                 return;
             }
-            stores.set(key, UtilsCache.Get(key));
+            stores.set(key, this.Get(key));
         });
         return stores;
     }
@@ -1291,15 +1293,15 @@ 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({});
             }
@@ -1312,8 +1314,8 @@ class UtilsCache {
                     return resolve({});
                 }
                 data.forEach(obj => {
-                    if (obj[UtilsCache.itemIndexByKey].startsWith(keyCacheStartWith)) {
-                        UtilsCache.ClearAsync(obj[UtilsCache.itemIndexByKey], true);
+                    if (obj[this.itemIndexByKey].startsWith(keyCacheStartWith)) {
+                        this.ClearAsync(obj[this.itemIndexByKey], true);
                     }
                 });
                 return resolve({});
@@ -1325,7 +1327,7 @@ 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;
         }
@@ -1337,17 +1339,17 @@ class UtilsCache {
     }
     static DeleteDatabaseIndexDB(dbName) {
         return new Promise((resolve, reject) => {
-            const request = indexedDB.deleteDatabase(dbName);
+            const request = indexedDB.deleteDatabase(dbName || this.dbName);
             request.onsuccess = () => {
-                console.log('Database deleted successfully');
+                console.trace('Database deleted successfully');
                 resolve(true);
             };
             request.onerror = (event) => {
-                console.error('Error deleting database:', event.target.error);
+                console.trace('Error deleting database:', event.target.error);
                 reject(event.target.error);
             };
             request.onblocked = () => {
-                console.warn('Delete request is blocked');
+                console.trace('Delete request is blocked');
             };
         });
     }