@libs-ui/utils 0.2.5

package/README.md

@@ -0,0 +1,3 @@
+# utils
+
+This library was generated with [Nx](https://nx.dev).

package/cache.d.ts

@@ -0,0 +1,41 @@
+export declare class UtilsCache {
+    private static typeKeyClearLocalStorage;
+    private static listKeyKeepWhenClearALll;
+    private static languageKeyCache;
+    private static initdEvent?;
+    private static readonly CACHE_EXPIRE_TIME_DEFAULT;
+    private static readonly CACHE_EXPIRE_NONE;
+    private static language;
+    private static idService;
+    private static storage;
+    private static dbName;
+    private static itemIndexByKey;
+    private static dbVersion;
+    private static db;
+    static init(config: {
+        indexedDBName?: string;
+        languageKeyCache?: string;
+        typeKeyClearLocalStorage?: string;
+        listKeyKeepWhenClearALll?: Array<string>;
+    }): void;
+    static setLang(lang: string): void;
+    static getLang(): string;
+    private static openDB;
+    private static getObjectStore;
+    private static get LocalStorage();
+    private static getLocalStorageFakeOnSafari;
+    private static getLocalStorageFake;
+    static GetAsync(key: string, default_value?: any, isKeyMD5?: boolean): Promise<any>;
+    static Get(key: string, default_value?: any): any;
+    private static GetDefaultValueBySpecificKey;
+    static SetAsync(key: string, value: any, expireTimeBySecond?: number, isKeyMD5?: boolean): Promise<unknown>;
+    static Set(key: string, value: any, expireTimeBySecond?: number): void;
+    static ClearAsync(key: string, isMD5?: boolean): Promise<unknown>;
+    static Clear(key: string): void;
+    static ClearAllAsync(): Promise<unknown>;
+    static ClearAll(): void;
+    private static GetDataByKeys;
+    private static SetDataByKey;
+    static DeleteKeyStartWithAsync(keyCacheStartWith: string, isKeyMD5?: boolean): Promise<unknown>;
+    static DeleteKeyStartWith(keyCache: string, isMD5?: boolean): void;
+}

package/color.d.ts

@@ -0,0 +1,11 @@
+export interface IColorContrastFromOrigin {
+    step: number;
+    label: string;
+    light: string;
+    dark: string;
+}
+export declare const colorStepContrastFromOrigin: (color: string, stepNumber: number) => IColorContrastFromOrigin | undefined;
+export declare const colorContrastFromOrigin: (color: string) => Array<IColorContrastFromOrigin>;
+export declare const rgbToHex: (rgb: any) => string;
+export declare const listColorDefine: Array<string>;
+export declare const GetColorById: (str: string) => string;

package/communicate-micro.d.ts

@@ -0,0 +1,17 @@
+import { Subject } from "rxjs";
+export declare class UtilsCommunicateMicro {
+    private static readonly KEY_GET_ALL_MESSAGE;
+    static readonly PREFIX_TYPE = "3RD_INTEGRATE_MICRO_SITE_";
+    private static initdEvent?;
+    private static subs;
+    private static allMessageSub;
+    static initEvent(currentWindow: Window): void;
+    static PostMessageToParent(data: any): void;
+    static PostMessageToChildren(data: any): void;
+    static PostMessageToOpener(data: any): void;
+    private static convertData;
+    static GetMessage(messageType: string | Array<string>): Subject<MessageEvent>;
+    private static initSubject;
+    postMessageToParent(data: unknown): void;
+    postMessageToChildren(data: unknown): void;
+}

package/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const ERROR_MESSAGE_EMPTY_VALID = "i18n_valid_empty_message";
+export declare const ERROR_MESSAGE_PATTEN_VALID = "i18n_valid_pattern_message";
+export declare const ERROR_MESSAGE_MIN_VALID = "i18n_message_error_input_min_value";
+export declare const ERROR_MESSAGE_MAX_VALID = "i18n_message_error_input_max_value";
+export declare const ERROR_MESSAGE_MIN_LENGTH = "i18n_message_error_input_min_length";
+export declare const ERROR_MESSAGE_MAX_LENGTH = "i18n_message_error_input_max_length";
+export declare const CHARACTER_DATA_EMPTY = "__";

package/crypto-3rd.d.ts

@@ -0,0 +1,3 @@
+export declare const setKeyCrypto3rd: (value: string) => void;
+export declare const encrypt3rd: (plainData: string) => string;
+export declare const decrypt3rd: (encryptedData: string) => string;

package/crypto.d.ts

@@ -0,0 +1,4 @@
+export declare const setKeyCrypto: (value: string) => void;
+export declare const encrypt: (plainData: string) => string;
+export declare const decrypt: (encryptedData: string) => string;
+export declare const md5: (plainData: string) => string;

package/delete-unicode.d.ts

@@ -0,0 +1 @@
+export declare const deleteUnicode: (str: string) => string;

package/dom.d.ts

@@ -0,0 +1,18 @@
+import { Renderer2 } from "@angular/core";
+import { IBoundingClientRect } from "@libs-ui/interfaces-types";
+export declare const getPlatFromBrowser: () => string;
+export declare const cloneIBoundingClientRect: (rect: IBoundingClientRect) => IBoundingClientRect;
+export declare const setStyles: (el: HTMLElement, styles: Record<string, string>, render2: Renderer2) => void;
+export declare const getViewport: (win?: Window) => {
+    width: number;
+    height: number;
+};
+export declare const setCaretPosition: (element: HTMLTextAreaElement | HTMLInputElement, position: number) => void;
+export declare const checkViewInScreen: (container: HTMLElement, element: HTMLElement, elementScroll?: HTMLElement, maxTopLeft?: {
+    top?: number;
+    left?: number;
+}) => boolean;
+export declare const checkMouseOverInContainer: (mousePosition: {
+    clientX: number;
+    clientY: number;
+}, element?: HTMLElement, rect?: DOMRect) => boolean;

package/escape-html.d.ts

@@ -0,0 +1 @@
+export declare const escapeHtml: (data: string) => string;

package/esm2022/cache.mjs

@@ -0,0 +1,396 @@
+/* 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 { UtilsLanguageConstants } from './language';
+import { uuid } from './uuid';
+export class UtilsCache {
+    static typeKeyClearLocalStorage = 'LIBS_UI_CLEAR_LOCAL_STORAGE_EVENT';
+    static listKeyKeepWhenClearALll = Array();
+    static languageKeyCache = 'SR3xQKxHgffiCevPQRralg';
+    static initdEvent;
+    static CACHE_EXPIRE_TIME_DEFAULT = 5 * 60;
+    static CACHE_EXPIRE_NONE = -1;
+    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) {
+            return;
+        }
+        UtilsCache.initdEvent = true;
+        if (config.indexedDBName) {
+            UtilsCache.dbName = config.indexedDBName;
+        }
+        if (config.typeKeyClearLocalStorage) {
+            UtilsCache.typeKeyClearLocalStorage = config.typeKeyClearLocalStorage;
+        }
+        if (config.listKeyKeepWhenClearALll) {
+            UtilsCache.listKeyKeepWhenClearALll = config.listKeyKeepWhenClearALll;
+        }
+        if (config.languageKeyCache) {
+            UtilsCache.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');
+        }
+        UtilsCache.language.set(lang);
+        UtilsCache.Set(UtilsCache.languageKeyCache, lang);
+    }
+    static getLang() {
+        return UtilsCache.language();
+    }
+    static openDB() {
+        return new Promise(resolve => {
+            const request = indexedDB.open(UtilsCache.dbName, UtilsCache.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 });
+                }
+            };
+            request.onsuccess = () => {
+                UtilsCache.db = request.result;
+                setTimeout(() => {
+                    UtilsCache.DeleteKeyStartWithAsync('');
+                }, 2000);
+                resolve(true);
+            };
+            request.onerror = (event) => {
+                console.error('Error opening IndexedDB:', event);
+                resolve(false);
+            };
+        });
+    }
+    static async getObjectStore() {
+        if (!UtilsCache.db) {
+            await UtilsCache.openDB();
+        }
+        const transaction = UtilsCache.db?.transaction([UtilsCache.dbName], 'readwrite');
+        return transaction?.objectStore(UtilsCache.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.log(error);
+            return this.getLocalStorageFake();
+        }
+    }
+    static getLocalStorageFakeOnSafari() {
+        if (typeof window.localStorage !== 'undefined' && !UtilsCache.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 (!UtilsCache.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, reject) => {
+            const objectStore = await UtilsCache.getObjectStore();
+            if (!objectStore) {
+                return resolve(default_value);
+            }
+            const index = objectStore.index(UtilsCache.itemIndexByKey);
+            const request = index.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) {
+                    return resolve(data.json);
+                }
+                const currentMillisecond = (new Date().valueOf() / 1000);
+                if (data.expire < currentMillisecond) {
+                    return resolve(default_value);
+                }
+                return resolve(data.json);
+            };
+            request.onerror = () => {
+                reject(request.error);
+            };
+        });
+    }
+    static Get(key, default_value) {
+        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 === UtilsCache.CACHE_EXPIRE_NONE) {
+                return data.value;
+            }
+            const currentMillisecond = (new Date().valueOf() / 1000);
+            if (data.expire < currentMillisecond) {
+                return this.GetDefaultValueBySpecificKey(key, default_value);
+            }
+            return data.value;
+        }
+        catch (error) {
+            console.log(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();
+            key = isKeyMD5 ? key : md5(key);
+            try {
+                const currentMillisecond = expireTimeBySecond === UtilsCache.CACHE_EXPIRE_NONE ? UtilsCache.CACHE_EXPIRE_NONE : (new Date().valueOf() / 1000) + expireTimeBySecond;
+                const data = {
+                    key: key,
+                    value: encrypt(JSON.stringify({ json: value, expire: currentMillisecond })),
+                };
+                if (!objectStore) {
+                    return resolve(-1);
+                }
+                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);
+                    };
+                };
+                getIndexKeyRequest.onerror = (event) => {
+                    console.error('Error fetching item by name:', event.target.error);
+                    reject(event.target.error);
+                };
+            }
+            catch (error) {
+                console.log(error);
+                resolve({});
+            }
+        });
+    }
+    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;
+        const data = {
+            value: value,
+            expire: currentMillisecond
+        };
+        try {
+            this.LocalStorage.setItem(key, encrypt(JSON.stringify(data)));
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    static async ClearAsync(key, isMD5 = false) {
+        return new Promise(async (resolve) => {
+            const objectStore = await UtilsCache.getObjectStore();
+            if (!objectStore) {
+                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({});
+            };
+            getRequest.onerror = () => {
+                resolve({});
+            };
+        });
+    }
+    static Clear(key) {
+        if (key.includes('kc-callback-')) {
+            return;
+        }
+        this.LocalStorage.removeItem(key);
+    }
+    static ClearAllAsync() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.deleteDatabase(this.dbName);
+            request.onsuccess = () => {
+                console.log('Database deleted successfully');
+                resolve(true);
+            };
+            request.onerror = (event) => {
+                console.error('Error deleting database:', event.target.error);
+                reject(event.target.error);
+            };
+            request.onblocked = () => {
+                console.warn('Delete request is blocked');
+            };
+        });
+    }
+    static ClearAll() {
+        const keys = [...UtilsCache.listKeyKeepWhenClearALll];
+        Object.keys(this.LocalStorage).forEach(key => {
+            if (key.includes('kc-callback-')) {
+                keys.push(key);
+            }
+        });
+        const stores = UtilsCache.GetDataByKeys(Array.from(keys));
+        this.LocalStorage.clear();
+        UtilsCache.SetDataByKey(stores);
+        const data = {
+            type: UtilsCache.typeKeyClearLocalStorage,
+            response: {
+                idEvent: this.idService
+            }
+        };
+        UtilsCommunicateMicro.PostMessageToParent(data);
+    }
+    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, UtilsCache.Get(key));
+        });
+        return stores;
+    }
+    static SetDataByKey(stores) {
+        stores.forEach((value, key) => {
+            if (key.includes('kc-callback-')) {
+                this.LocalStorage.setItem(key, value);
+                return;
+            }
+            if (key === UtilsCache.languageKeyCache) {
+                return UtilsCache.setLang(value);
+            }
+            UtilsCache.Set(key, value, UtilsCache.CACHE_EXPIRE_NONE);
+        });
+    }
+    static DeleteKeyStartWithAsync(keyCacheStartWith, isKeyMD5 = false) {
+        return new Promise(async (resolve) => {
+            const objectStore = await UtilsCache.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();
+            keyCacheStartWith = isKeyMD5 ? keyCacheStartWith : md5(keyCacheStartWith);
+            request.onsuccess = (e) => {
+                const data = e.target.result;
+                if (!Array.isArray(data)) {
+                    return resolve({});
+                }
+                data.forEach(obj => {
+                    if (obj.key.startsWith(keyCacheStartWith)) {
+                        UtilsCache.ClearAsync(obj.key, true);
+                    }
+                });
+                return resolve({});
+            };
+            request.onerror = () => {
+                return resolve({});
+            };
+        });
+    }
+    static DeleteKeyStartWith(keyCache, isMD5 = false) {
+        keyCache = isMD5 ? md5(keyCache) : keyCache;
+        const keys = Object.keys(UtilsCache.LocalStorage);
+        if (!keys || !keys.length) {
+            return;
+        }
+        keys.forEach(key => {
+            if (key.startsWith(keyCache)) {
+                this.Clear(key);
+            }
+        });
+    }
+}
+//# 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  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 readonly CACHE_EXPIRE_NONE = -1;\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"]}