@libs-ui/utils 0.1.1-1

package/esm2022/cache.mjs

@@ -0,0 +1,388 @@
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { UtilsCommunicateMicro } from './communicate-micro';
+import { decrypt, encrypt, md5 } from './crypto';
+import { getPlatFromBrowser } from './dom';
+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 languageKeyCache = 'SR3xQKxHgffiCevPQRralg';
+    static listKeyKeepWhenClearALll = Array();
+    static initdEvent;
+    static storage;
+    static dbName = 'libs-ui-cache';
+    static itemIndexByKey = 'key';
+    static dbVersion = 1;
+    static db = null;
+    static init(config) {
+        if (this.initdEvent) {
+            return;
+        }
+        this.initdEvent = true;
+        if (config.indexedDBName) {
+            this.dbName = config.indexedDBName;
+        }
+        if (config.typeKeyClearLocalStorage) {
+            this.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;
+        }
+        if (config.listKeyKeepWhenClearAll) {
+            this.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearAll;
+        }
+        if (config.languageKeyCache) {
+            this.languageKeyCache = config.languageKeyCache;
+        }
+    }
+    static setLang(lang) {
+        if (!UtilsLanguageConstants.isSupported(lang)) {
+            throw Error(`Language not support ${lang}`);
+        }
+        this.Set(this.languageKeyCache, lang, this.CACHE_EXPIRE_NONE);
+    }
+    static getLang() {
+        return this.Get(this.languageKeyCache, UtilsLanguageConstants.defaultLang);
+    }
+    static openDB() {
+        return new Promise((resolve) => {
+            const request = indexedDB.open(this.dbName, this.dbVersion);
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                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 = () => {
+                this.db = request.result;
+                resolve(true);
+            };
+            request.onerror = (event) => {
+                console.trace('Error opening IndexedDB:', event);
+                resolve(false);
+            };
+        });
+    }
+    static async getObjectStore() {
+        if (!this.db) {
+            await this.openDB();
+        }
+        const transaction = this.db?.transaction([this.dbName], 'readwrite');
+        if (!transaction) {
+            return null;
+        }
+        return transaction.objectStore(this.dbName);
+    }
+    static get LocalStorage() {
+        try {
+            if (typeof window.localStorage !== 'undefined') {
+                const OS = getPlatFromBrowser();
+                if (OS.includes('Safari') && parseFloat(OS.split(' ').pop() || '0') >= 16) {
+                    return this.getLocalStorageFakeOnSafari();
+                }
+                return localStorage;
+            }
+            return this.getLocalStorageFake();
+        }
+        catch (error) {
+            console.trace(`LocalStorage `, error);
+            return this.getLocalStorageFake();
+        }
+    }
+    static getLocalStorageFakeOnSafari() {
+        if (typeof window.localStorage !== 'undefined' && !this.storage && Object.keys(localStorage).length) {
+            this.storage = { ...localStorage };
+        }
+        return {
+            setItem: (key, value) => {
+                localStorage.setItem(key, value);
+                this.storage[key] = value;
+            },
+            getItem: (key) => {
+                const value = localStorage.getItem(key);
+                if (value) {
+                    return value;
+                }
+                if (!this.storage || isNil(this.storage[key])) {
+                    return null;
+                }
+                localStorage.setItem(key, this.storage[key]);
+                return this.storage?.[key];
+            },
+            removeItem: (key) => {
+                delete this.storage?.[key];
+                localStorage.removeItem(key);
+            },
+            clear: () => {
+                this.storage = {};
+                localStorage.clear();
+            },
+        };
+    }
+    static getLocalStorageFake() {
+        if (!this.storage) {
+            this.storage = {};
+        }
+        return {
+            setItem: (key, value) => {
+                this.storage[key] = value;
+            },
+            getItem: (key) => {
+                return this.storage?.[key];
+            },
+            removeItem: (key) => {
+                delete this.storage?.[key];
+            },
+            clear: () => {
+                this.storage = {};
+            },
+        };
+    }
+    static async GetAsync(key, default_value, isKeyMD5 = false) {
+        key = isKeyMD5 ? key : md5(key);
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve(default_value);
+            }
+            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 === this.CACHE_EXPIRE_NONE) {
+                    return resolve(data.json);
+                }
+                const currentMillisecond = new Date().valueOf() / 1000;
+                if (data.expire < currentMillisecond) {
+                    return resolve(default_value);
+                }
+                return resolve(data.json);
+            };
+            request.onerror = () => {
+                console.trace(`Get key ${key} Error, return default value: ${default_value}`);
+                return resolve(default_value);
+            };
+        });
+    }
+    static Get(key, default_value) {
+        // support cho những file không thể inject UtilsCache
+        if (!key) {
+            return this.GetDefaultValueBySpecificKey(key, default_value);
+        }
+        const cachedData = this.LocalStorage.getItem(key);
+        if (!cachedData) {
+            return this.GetDefaultValueBySpecificKey(key, default_value);
+        }
+        try {
+            const data = JSON.parse(decrypt(cachedData));
+            if (data.expire === this.CACHE_EXPIRE_NONE) {
+                return data.value ?? default_value;
+            }
+            const currentMillisecond = new Date().valueOf() / 1000;
+            if (data.expire < currentMillisecond) {
+                return this.GetDefaultValueBySpecificKey(key, default_value);
+            }
+            return data.value;
+        }
+        catch (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 = this.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false) {
+        // support inject UtilsCache
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            key = isKeyMD5 ? key : md5(key);
+            try {
+                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[this.itemIndexByKey] = key;
+                if (!objectStore) {
+                    console.trace(`Can not open object store`);
+                    return resolve({ key, messageError: 'Can not open object store' });
+                }
+                const request = objectStore?.put(data);
+                request.onsuccess = () => {
+                    console.log(`Set key ${key} Success`);
+                    resolve(request.result);
+                };
+                request.onerror = (error) => {
+                    console.trace(`Set key ${key} Error`);
+                    resolve({ key, messageError: get(error, 'message') });
+                };
+            }
+            catch (error) {
+                console.trace(`Set key ${key} Error`);
+                resolve({ key, messageError: get(error, 'message') });
+            }
+        });
+    }
+    static Set(key, value, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT) {
+        // support cho những file không inject UtilsCache
+        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.trace(`Set key ${key} Error`, error);
+            return false;
+        }
+    }
+    static async ClearAsync(key, isMD5 = false) {
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve();
+            }
+            const request = objectStore.delete(isMD5 ? key : md5(key));
+            request.onsuccess = () => {
+                resolve({ clearSuccess: true });
+            };
+            request.onerror = (event) => {
+                console.trace('Error deleting Key:', get(event.target.error, 'message'));
+                resolve({ messageError: get(event.target.error, 'message'), clearSuccess: false });
+            };
+        });
+    }
+    static Clear(key) {
+        if (key.includes('kc-callback-')) {
+            return;
+        }
+        this.LocalStorage.removeItem(key);
+    }
+    static ClearAllAsync() {
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve();
+            }
+            const request = objectStore.clear();
+            request.onsuccess = () => {
+                console.log('clear all successfully');
+                resolve({ clearSuccess: true });
+            };
+            request.onerror = (event) => {
+                console.trace('Error deleting key:', get(event.target.error, 'message'));
+                resolve({ messageError: get(event.target.error, 'message'), clearSuccess: false });
+            };
+        });
+    }
+    static ClearAll() {
+        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 = this.GetDataByKeys(Array.from(keys));
+        this.LocalStorage.clear();
+        this.SetDataByKey(stores);
+    }
+    static GetDataByKeys(keys) {
+        const stores = new Map();
+        keys.forEach((key) => {
+            if (key.includes('kc-callback-')) {
+                stores.set(key, this.LocalStorage.getItem(key));
+                return;
+            }
+            stores.set(key, this.Get(key));
+        });
+        return stores;
+    }
+    static SetDataByKey(stores) {
+        stores.forEach((value, key) => {
+            if (key.includes('kc-callback-')) {
+                this.LocalStorage.setItem(key, value);
+                return;
+            }
+            if (key === this.languageKeyCache) {
+                return this.setLang(value);
+            }
+            this.Set(key, value, this.CACHE_EXPIRE_NONE);
+        });
+    }
+    static DeleteKeyStartWithAsync(keyCacheStartWith, isKeyMD5 = false) {
+        return new Promise(async (resolve) => {
+            const objectStore = await this.getObjectStore();
+            if (!objectStore) {
+                return resolve({});
+            }
+            // Lấy tất cả các keys từ index
+            const request = objectStore.getAll();
+            keyCacheStartWith = isKeyMD5 ? keyCacheStartWith : md5(keyCacheStartWith);
+            request.onsuccess = (e) => {
+                const data = e.target.result;
+                if (!Array.isArray(data)) {
+                    return resolve({});
+                }
+                data.forEach((obj) => {
+                    if (obj[this.itemIndexByKey].startsWith(keyCacheStartWith)) {
+                        this.ClearAsync(obj[this.itemIndexByKey], true);
+                    }
+                });
+                return resolve({});
+            };
+            request.onerror = () => {
+                return resolve({});
+            };
+        });
+    }
+    static DeleteKeyStartWith(keyCache, isMD5 = false) {
+        keyCache = isMD5 ? md5(keyCache) : keyCache;
+        const keys = Object.keys(this.LocalStorage);
+        if (!keys || !keys.length) {
+            return;
+        }
+        keys.forEach((key) => {
+            if (key.startsWith(keyCache)) {
+                this.Clear(key);
+            }
+        });
+    }
+    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 { 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          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        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          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 {\n    // 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    } 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  public static async SetAsync<T = any>(key: string, value: any, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT, isKeyMD5 = false): Promise<T> {\n    // 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      } catch (error) {\n        console.trace(`Set key ${key} Error`);\n        resolve({ key, messageError: get(error, 'message') } as any);\n      }\n    });\n  }\n\n  static Set(key: string, value: any, expireTimeBySecond = this.CACHE_EXPIRE_TIME_DEFAULT): boolean {\n    // 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      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"]}

package/esm2022/color.mjs

@@ -0,0 +1,133 @@
+const step = 20;
+const percent = 0.05;
+export const colorStepContrastFromOrigin = (color, stepNumber) => {
+    return colorContrastFromOrigin(color).find((item) => item.step === stepNumber);
+};
+export const colorContrastFromOrigin = (color) => {
+    const parsedColorsArray = parseColorValues(color);
+    const colors = [];
+    let calculatedShades = [];
+    let calculatedTints = [];
+    if (parsedColorsArray !== null) {
+        for (let i = 0; i < parsedColorsArray.length; i++) {
+            calculatedShades = calculateShades(parsedColorsArray[i]);
+            calculatedTints = calculateTints(parsedColorsArray[i]);
+        }
+        for (let i = 0; i <= step; i++) {
+            colors.push({ step: i * 5, label: `${i * 5}%`, dark: `#${calculatedShades[i]}`, light: `#${calculatedTints[i]}` });
+        }
+    }
+    return colors;
+};
+const parseColorValues = (colorValues) => {
+    let colorValuesArray = colorValues.match(/\b[0-9A-Fa-f]{3}\b|[0-9A-Fa-f]{6}\b/g);
+    if (colorValuesArray) {
+        colorValuesArray = colorValuesArray.map((item) => {
+            if (item.length === 3) {
+                let newItem = item.toString().split('');
+                newItem = newItem.reduce((acc, it) => {
+                    return acc + it + it;
+                }, '');
+                return newItem;
+            }
+            return item;
+        });
+    }
+    return colorValuesArray;
+};
+const calculateShades = (colorValue) => {
+    return calculate(colorValue, rgbShade).concat('000000');
+};
+const calculateTints = (colorValue) => {
+    return calculate(colorValue, rgbTint).concat('ffffff');
+};
+const calculate = (colorValue, shadeOrTint) => {
+    const color = hexToRGB(colorValue);
+    const shadeValues = [];
+    for (let i = 0; i < step; i++) {
+        shadeValues[i] = rgbToHex(shadeOrTint(color, i));
+    }
+    return shadeValues;
+};
+const rgbShade = (rgb, i) => {
+    return { red: rgb.red * (1 - percent * i), green: rgb.green * (1 - percent * i), blue: rgb.blue * (1 - percent * i) };
+};
+const rgbTint = (rgb, i) => {
+    return { red: rgb.red + (255 - rgb.red) * i * percent, green: rgb.green + (255 - rgb.green) * i * percent, blue: rgb.blue + (255 - rgb.blue) * i * percent };
+};
+export const rgbToHex = (rgb) => {
+    return intToHex(rgb.red) + intToHex(rgb.green) + intToHex(rgb.blue);
+};
+const hexToRGB = (colorValue) => {
+    return { red: parseInt(colorValue.substr(0, 2), 16), green: parseInt(colorValue.substr(2, 2), 16), blue: parseInt(colorValue.substr(4, 2), 16) };
+};
+const intToHex = (rgbint) => {
+    return pad(Math.min(Math.max(Math.round(rgbint), 0), 255).toString(16), 2);
+};
+const pad = (number, length) => {
+    let str = '' + number;
+    while (str.length < length) {
+        str = '0' + str;
+    }
+    return str;
+};
+export const listColorDefine = [
+    '#E62222',
+    '#B81B1B',
+    '#EB4E4E',
+    '#F97316',
+    '#C75C12',
+    '#FA8F45',
+    '#FFB700',
+    '#CC9200',
+    '#FFC533',
+    '#84CC16',
+    '#6AA312',
+    '#9dd645',
+    '#00BC62',
+    '#00A757',
+    '#33DA8A',
+    '#06B6D4',
+    '#1B59C4',
+    '#4E8CF7',
+    '#0EA5E9',
+    '#1B59C4',
+    '#4E8CF7',
+    '#226FF5',
+    '#1B59C4',
+    '#4E8CF7',
+    '#6366F1',
+    '#4F52C1',
+    '#8285F4',
+    '#5B04B3',
+    '#49038F',
+    '#7C36C2',
+    '#D946EF',
+    '#AE38BF',
+    '#E16BF2',
+    '#EC4899',
+    '#BD3A7A',
+    '#F06DAD',
+    '#F43F5E',
+    '#C3324B',
+    '#F6657E',
+    '#757380',
+    '#5E5C66',
+    '#918F99',
+    '#202020',
+    '#1A1A1A',
+    '#4D4D4D',
+];
+export const getColorById = (str) => {
+    let hashString = 0;
+    if (!str) {
+        return '';
+    }
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hashString = (hashString << 5) - hashString + char;
+        hashString = hashString & hashString;
+    }
+    return listColorDefine[Math.abs(hashString) % listColorDefine.length];
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"color.js","sourceRoot":"","sources":["../../../../libs-ui/utils/src/color.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nexport interface IColorContrastFromOrigin {\n  step: number;\n  label: string;\n  light: string;\n  dark: string;\n}\n\nconst step = 20;\nconst percent = 0.05;\n\nexport const colorStepContrastFromOrigin = (color: string, stepNumber: number) => {\n  return colorContrastFromOrigin(color).find((item) => item.step === stepNumber);\n};\n\nexport const colorContrastFromOrigin = (color: string): Array<IColorContrastFromOrigin> => {\n  const parsedColorsArray = parseColorValues(color);\n  const colors: any = [];\n  let calculatedShades: Array<string> = [];\n  let calculatedTints: Array<string> = [];\n\n  if (parsedColorsArray !== null) {\n    for (let i = 0; i < parsedColorsArray.length; i++) {\n      calculatedShades = calculateShades(parsedColorsArray[i]);\n      calculatedTints = calculateTints(parsedColorsArray[i]);\n    }\n\n    for (let i = 0; i <= step; i++) {\n      colors.push({ step: i * 5, label: `${i * 5}%`, dark: `#${calculatedShades[i]}`, light: `#${calculatedTints[i]}` });\n    }\n  }\n\n  return colors;\n};\n\nconst parseColorValues = (colorValues: any) => {\n  let colorValuesArray = colorValues.match(/\\b[0-9A-Fa-f]{3}\\b|[0-9A-Fa-f]{6}\\b/g);\n\n  if (colorValuesArray) {\n    colorValuesArray = colorValuesArray.map((item: any) => {\n      if (item.length === 3) {\n        let newItem = item.toString().split('');\n\n        newItem = newItem.reduce((acc: any, it: any) => {\n          return acc + it + it;\n        }, '');\n\n        return newItem;\n      }\n\n      return item;\n    });\n  }\n\n  return colorValuesArray;\n};\n\nconst calculateShades = (colorValue: any) => {\n  return calculate(colorValue, rgbShade).concat('000000');\n};\n\nconst calculateTints = (colorValue: any) => {\n  return calculate(colorValue, rgbTint).concat('ffffff');\n};\n\nconst calculate = (colorValue: any, shadeOrTint: any) => {\n  const color = hexToRGB(colorValue);\n  const shadeValues: Array<string> = [];\n\n  for (let i = 0; i < step; i++) {\n    shadeValues[i] = rgbToHex(shadeOrTint(color, i));\n  }\n\n  return shadeValues;\n};\n\nconst rgbShade = (rgb: any, i: any) => {\n  return { red: rgb.red * (1 - percent * i), green: rgb.green * (1 - percent * i), blue: rgb.blue * (1 - percent * i) };\n};\nconst rgbTint = (rgb: any, i: any) => {\n  return { red: rgb.red + (255 - rgb.red) * i * percent, green: rgb.green + (255 - rgb.green) * i * percent, blue: rgb.blue + (255 - rgb.blue) * i * percent };\n};\n\nexport const rgbToHex = (rgb: any) => {\n  return intToHex(rgb.red) + intToHex(rgb.green) + intToHex(rgb.blue);\n};\nconst hexToRGB = (colorValue: any) => {\n  return { red: parseInt(colorValue.substr(0, 2), 16), green: parseInt(colorValue.substr(2, 2), 16), blue: parseInt(colorValue.substr(4, 2), 16) };\n};\nconst intToHex = (rgbint: any) => {\n  return pad(Math.min(Math.max(Math.round(rgbint), 0), 255).toString(16), 2);\n};\n\nconst pad = (number: any, length: any) => {\n  let str = '' + number;\n\n  while (str.length < length) {\n    str = '0' + str;\n  }\n\n  return str;\n};\n\nexport const listColorDefine: Array<string> = [\n  '#E62222',\n  '#B81B1B',\n  '#EB4E4E',\n  '#F97316',\n  '#C75C12',\n  '#FA8F45',\n  '#FFB700',\n  '#CC9200',\n  '#FFC533',\n  '#84CC16',\n  '#6AA312',\n  '#9dd645',\n  '#00BC62',\n  '#00A757',\n  '#33DA8A',\n  '#06B6D4',\n  '#1B59C4',\n  '#4E8CF7',\n  '#0EA5E9',\n  '#1B59C4',\n  '#4E8CF7',\n  '#226FF5',\n  '#1B59C4',\n  '#4E8CF7',\n  '#6366F1',\n  '#4F52C1',\n  '#8285F4',\n  '#5B04B3',\n  '#49038F',\n  '#7C36C2',\n  '#D946EF',\n  '#AE38BF',\n  '#E16BF2',\n  '#EC4899',\n  '#BD3A7A',\n  '#F06DAD',\n  '#F43F5E',\n  '#C3324B',\n  '#F6657E',\n  '#757380',\n  '#5E5C66',\n  '#918F99',\n  '#202020',\n  '#1A1A1A',\n  '#4D4D4D',\n];\n\nexport const getColorById = (str: string): string => {\n  let hashString = 0;\n\n  if (!str) {\n    return '';\n  }\n  for (let i = 0; i < str.length; i++) {\n    const char = str.charCodeAt(i);\n\n    hashString = (hashString << 5) - hashString + char;\n    hashString = hashString & hashString;\n  }\n\n  return listColorDefine[Math.abs(hashString) % listColorDefine.length];\n};\n"]}