@libs-ui/utils 0.2.5

package/fesm2022/libs-ui-utils.mjs

@@ -0,0 +1,1426 @@
+import { TemplateRef, ElementRef, signal } from '@angular/core';
+import CryptoES from 'crypto-es';
+import { HttpParams } from '@angular/common/http';
+import { Subject, fromEvent, filter } from 'rxjs';
+
+const getPlatFromBrowser = () => {
+    const userAgent = navigator.userAgent;
+    let tem;
+    let match = userAgent.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+    if (/trident/i.test(match[1])) {
+        tem = /\brv[ :]+(\d+)/g.exec(userAgent) || [];
+        return 'IE ' + (tem[1] || '');
+    }
+    if (match[1] === 'Chrome') {
+        tem = userAgent.match(/\b(OPR|Edge)\/(\d+)/);
+        if (tem !== null) {
+            return tem.slice(1).join(' ').replace('OPR', 'Opera');
+        }
+    }
+    match = match[2] ? [match[1], match[2]] : [navigator.appName, navigator.appVersion, '-?'];
+    if ((tem = userAgent.match(/version\/(\d+)/i)) !== null) {
+        match.splice(1, 1, tem[1]);
+    }
+    return match.join(' ');
+};
+const cloneIBoundingClientRect = (rect) => {
+    return {
+        top: rect['top'],
+        left: rect['left'],
+        width: rect['width'],
+        height: rect['height'],
+        bottom: rect['bottom']
+    };
+};
+const setStyles = (el, styles, render2) => {
+    Object.keys(styles).forEach((key) => render2.setStyle(el, key, styles[key]));
+};
+const getViewport = (win = window) => {
+    const doc = win.document.documentElement, body = win.document.getElementsByTagName('body')[0], w = win.innerWidth || doc.clientWidth || body.clientWidth, h = win.innerHeight || doc.clientHeight || body.clientHeight;
+    return { width: w, height: h };
+};
+const setCaretPosition = (element, position) => {
+    if (!element || !element.setSelectionRange) {
+        return;
+    }
+    element.focus();
+    element.setSelectionRange(position, position);
+};
+const checkViewInScreen = (container, element, elementScroll, maxTopLeft) => {
+    if (!container || !element) {
+        return false;
+    }
+    const rectContainer = cloneIBoundingClientRect(container.getBoundingClientRect());
+    if (elementScroll) {
+        const rectElementScroll = elementScroll.getBoundingClientRect();
+        rectContainer['left'] = rectElementScroll.left;
+        rectContainer['top'] = rectElementScroll.top;
+    }
+    const rectElement = element.getBoundingClientRect();
+    const { left, top } = rectElement;
+    const topContainer = rectContainer['top'];
+    const leftContainer = rectContainer['left'];
+    const widthContainer = rectContainer['width'];
+    const heightContainer = rectContainer['height'];
+    const scrollTopContainer = container.scrollTop;
+    const scrollLeftContainer = container.scrollLeft;
+    const limitTop = topContainer + scrollTopContainer + heightContainer;
+    const limitLeft = leftContainer + scrollLeftContainer + widthContainer;
+    const maxTopItem = top + (maxTopLeft?.top || 0);
+    const maxLeftItem = left + (maxTopLeft?.left || 0);
+    if (topContainer <= maxTopItem && maxTopItem <= limitTop && leftContainer <= maxLeftItem && maxLeftItem <= limitLeft) {
+        return true;
+    }
+    return false;
+};
+const checkMouseOverInContainer = (mousePosition, element, rect) => {
+    if (!element && !rect) {
+        return false;
+    }
+    const rectElement = rect || element?.getBoundingClientRect() || {};
+    const { left, top, width, height } = rectElement;
+    const limitLeft = left + width;
+    const limitTop = top + height;
+    const { clientX, clientY } = mousePosition;
+    if (left <= clientX && clientX <= limitLeft && top <= clientY && clientY <= limitTop) {
+        return true;
+    }
+    return false;
+};
+
+class UtilsUrlSearchParams {
+    static instance;
+    params;
+    constructor(paramString) {
+        this.params = new Array();
+        this.params.length = 0;
+        this.params.push(...this.buildParams(paramString));
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new UtilsUrlSearchParams('');
+        }
+        return this.instance;
+    }
+    static toStringParamObject(params) {
+        const paramsArr = Object.keys(params).map(key => {
+            return {
+                key,
+                value: params[key]
+            };
+        });
+        return UtilsUrlSearchParams.ToString(paramsArr);
+    }
+    static ToString(params) {
+        let paramsStr = '';
+        params.sort((item1, item2) => item1.key.localeCompare(item2.key)).forEach((item) => {
+            const { key, value } = item;
+            paramsStr = `${paramsStr}${paramsStr ? '&' : ''}${key}=${value}`;
+        });
+        return paramsStr;
+    }
+    buildParams(paramString) {
+        const paramsBuild = new Array();
+        if (!paramString) {
+            return paramsBuild;
+        }
+        const paramsError = paramString.split('?');
+        if (paramsError.length > 2) {
+            paramString = `${paramsError[0]}?${paramsError[1]}&${paramsError.slice(2).join('&')}`;
+        }
+        const params = paramString.replace(/\S+[?]/g, '').split('&');
+        if (params) {
+            params.forEach(param => {
+                if (param.indexOf('=') < 0) {
+                    return;
+                }
+                let [key, value] = param.split('=');
+                key = key.replace(/[?&]+/g, '');
+                value = decodeURIComponent(value.replace(/\+/g, ' '));
+                if (!paramsBuild.some(param => param.key === key)) {
+                    paramsBuild.push({ key, value });
+                }
+            });
+        }
+        return paramsBuild;
+    }
+    set(key, value) {
+        const paramByKey = this.params.find(param => param.key === key);
+        if (!paramByKey) {
+            this.params.push({ key, value: decodeURIComponent(value.replace(/\+/g, ' ')) });
+            return;
+        }
+        paramByKey['value'] = value;
+    }
+    get(key) {
+        return this.params.find(param => param.key === key)?.value;
+    }
+    has(key) {
+        return this.params.some(param => param.key === key);
+    }
+    delete(key) {
+        const index = this.params.findIndex(param => param.key === key);
+        if (index >= 0) {
+            this.params.splice(index, 1);
+        }
+    }
+    length() {
+        return this.params.length;
+    }
+    toString(params) {
+        params = params || this.params;
+        return UtilsUrlSearchParams.ToString(params);
+    }
+    getParamObject() {
+        const params = {};
+        this.params.forEach(item => {
+            params[item.key] = item.value;
+        });
+        return params;
+    }
+    compareParams(param1, param2) {
+        const params1 = this.toString(this.buildParams(param1));
+        const params2 = this.toString(this.buildParams(param2));
+        return params1 === params2;
+    }
+}
+
+const uuid = () => {
+    const timestamp = performance.now() * 1000;
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=[]{}|;:,.<>?/~';
+    let randomString = '';
+    for (let i = 0; i < 5; i++) {
+        randomString += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    const baseString = `${Math.floor(timestamp)}-${randomString}`;
+    const charArray = baseString.split('');
+    for (let i = charArray.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [charArray[i], charArray[j]] = [charArray[j], charArray[i]];
+    }
+    const shuffledString = charArray.join('');
+    return shuffledString;
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const isNil = (value) => {
+    return value === null || value === undefined;
+};
+const isEmpty = (value) => {
+    return value === null || value === '' || value === undefined || (typeof value === 'object' && (JSON.stringify(value) === '{}' || JSON.stringify(value) === '[]'));
+};
+const get = (obj, path, defaultValue = undefined) => {
+    if (obj == null) {
+        return defaultValue;
+    }
+    const paths = Array.isArray(path) ? path : path.replace(/\[(\d+)]/g, '.$1').split('.');
+    for (let i = 0; i < paths.length; i++) {
+        if (obj == null || !Object.prototype.hasOwnProperty.call(obj, paths[i])) {
+            return defaultValue;
+        }
+        obj = obj[paths[i]];
+    }
+    return obj;
+};
+const set = (obj, path, value) => {
+    if (!obj || typeof obj !== "object") {
+        throw new Error("The first argument must be an object");
+    }
+    const pathArray = Array.isArray(path) ? path : path.replace(/\[(\d+)]/g, '.[$1]').split('.');
+    let current = obj;
+    pathArray.forEach((key, index) => {
+        if (index < pathArray.length - 1) {
+            if (!(key in current) || typeof current[key] !== "object") {
+                const nextKey = pathArray[index + 1];
+                key = key.replace(/\[(\d+)]/g, '$1');
+                current[key] = /\[(\d+)]/g.test(nextKey) ? [] : {};
+            }
+            current = current[key];
+            return;
+        }
+        // Gán giá trị ở cuối đường dẫn
+        current[key] = value;
+    });
+    return obj;
+};
+const cloneDeep = (value) => {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (value instanceof RegExp) {
+        return new RegExp(value.source, value.flags);
+    }
+    if (value instanceof Map) {
+        const mapCopy = new Map();
+        value.forEach((val, key) => {
+            mapCopy.set(cloneDeep(key), cloneDeep(val));
+        });
+        return mapCopy;
+    }
+    if (value instanceof Set) {
+        const setCopy = new Set();
+        value.forEach(val => {
+            setCopy.add(cloneDeep(val));
+        });
+        return setCopy;
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => cloneDeep(item));
+    }
+    const result = {};
+    for (const key in value) {
+        if (value[key] instanceof TemplateRef || value[key] instanceof ElementRef || value[key] instanceof Element) {
+            result[key] = value[key];
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+            result[key] = cloneDeep(value[key]);
+        }
+    }
+    return result;
+};
+const generateInterface = (obj, interfaceName) => {
+    const generateType = (value) => {
+        if (value === null) {
+            return 'null';
+        }
+        const type = typeof value;
+        if (type === 'string') {
+            return 'string';
+        }
+        if (type === 'number') {
+            return 'number';
+        }
+        if (type === 'boolean') {
+            return 'boolean';
+        }
+        if (type === 'undefined') {
+            return 'any';
+        }
+        if (value instanceof Date) {
+            return 'Date';
+        }
+        if (value instanceof RegExp) {
+            return 'RegExp';
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                return 'Array<any>';
+            }
+            return `Array<${generateType(value[0])}>`;
+        }
+        if (type === 'object') {
+            let interfaceStr = '{\n';
+            for (const key in value) {
+                if (Object.prototype.hasOwnProperty.call(value, key)) {
+                    const valueType = generateType(value[key]);
+                    interfaceStr += `  ${key}: ${valueType};\n`;
+                }
+            }
+            interfaceStr += '}';
+            return interfaceStr;
+        }
+        return 'any';
+    };
+    const interfaceStr = `interface ${interfaceName} ${generateType(obj)}`;
+    return interfaceStr;
+};
+
+;
+const step = 20;
+const percent = 0.05;
+const colorStepContrastFromOrigin = (color, stepNumber) => {
+    return colorContrastFromOrigin(color).find(item => item.step === stepNumber);
+};
+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 }; };
+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;
+};
+const listColorDefine$1 = ['#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'
+];
+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$1[Math.abs(hashString) % listColorDefine$1.length];
+};
+
+let key$1 = '12~@#loqwsxacva(3rdhaq12';
+const setKeyCrypto = (value) => {
+    if (value.length !== 24 && value.length !== 32) {
+        throw Error(`key.length = ${value.length}; Key phải là 1 chuỗi dài 24 hoặc 32 ký tự`);
+    }
+    key$1 = value;
+};
+const keyStore$1 = () => {
+    return key$1;
+};
+const encrypt = (plainData) => {
+    if (!keyStore$1()) {
+        throw Error("lỗi chưa setup key mã hóa");
+    }
+    const key = CryptoES.enc.Hex.parse(keyStore$1());
+    const iv = CryptoES.enc.Hex.parse(keyStore$1());
+    const mode = CryptoES.mode.CBC;
+    const padding = CryptoES.pad.Pkcs7;
+    const options = { iv: iv, mode: mode, padding: padding };
+    return CryptoES.AES.encrypt(plainData, key, options).toString();
+};
+const decrypt = (encryptedData) => {
+    if (!keyStore$1()) {
+        throw Error("lỗi chưa setup key mã hóa");
+    }
+    const key = CryptoES.enc.Hex.parse(keyStore$1());
+    const iv = CryptoES.enc.Hex.parse(keyStore$1());
+    const mode = CryptoES.mode.CBC;
+    const padding = CryptoES.pad.Pkcs7;
+    const options = { iv: iv, mode: mode, padding: padding };
+    return CryptoES.AES.decrypt(encryptedData, key, options).toString(CryptoES.enc.Utf8);
+};
+const md5 = (plainData) => {
+    return CryptoES.MD5(plainData).toString();
+};
+
+let key = '12~@#loqwsxacva(3rdhaq12';
+const setKeyCrypto3rd = (value) => {
+    if (value.length !== 24 && value.length !== 32) {
+        throw Error(`key.length = ${value.length}; Key phải là 1 chuỗi dài 24 hoặc 32 ký tự`);
+    }
+    key = value;
+};
+const keyStore = () => {
+    return key;
+};
+const encrypt3rd = (plainData) => {
+    if (!keyStore()) {
+        throw Error("lỗi chưa setup key mã hóa");
+    }
+    const key = CryptoES.enc.Hex.parse(keyStore());
+    const iv = CryptoES.enc.Hex.parse(keyStore());
+    const mode = CryptoES.mode.CBC;
+    const padding = CryptoES.pad.Pkcs7;
+    const options = { iv: iv, mode: mode, padding: padding };
+    return CryptoES.AES.encrypt(plainData, key, options).toString();
+};
+const decrypt3rd = (encryptedData) => {
+    if (!keyStore()) {
+        throw Error("lỗi chưa setup key mã hóa");
+    }
+    const key = CryptoES.enc.Hex.parse(keyStore());
+    const iv = CryptoES.enc.Hex.parse(keyStore());
+    const mode = CryptoES.mode.CBC;
+    const padding = CryptoES.pad.Pkcs7;
+    const options = { iv: iv, mode: mode, padding: padding };
+    return CryptoES.AES.decrypt(encryptedData, key, options).toString(CryptoES.enc.Utf8);
+};
+
+class UtilsKeyCodeConstant {
+    static MAC_ENTER = 3;
+    static BACKSPACE = 8;
+    static TAB = 9;
+    static NUM_CENTER = 12;
+    static ENTER = 13;
+    static SHIFT = 16;
+    static CONTROL = 17;
+    static ALT = 18;
+    static PAUSE = 19;
+    static CAPS_LOCK = 20;
+    static ESCAPE = 27;
+    static SPACE = 32;
+    static PAGE_UP = 33;
+    static PAGE_DOWN = 34;
+    static END = 35;
+    static HOME = 36;
+    static LEFT_ARROW = 37;
+    static UP_ARROW = 38;
+    static RIGHT_ARROW = 39;
+    static DOWN_ARROW = 40;
+    static PLUS_SIGN = 43;
+    static PRINT_SCREEN = 44;
+    static INSERT = 45;
+    static DELETE = 46;
+    static ZERO = 48;
+    static ONE = 49;
+    static TWO = 50;
+    static THREE = 51;
+    static FOUR = 52;
+    static FIVE = 53;
+    static SIX = 54;
+    static SEVEN = 55;
+    static EIGHT = 56;
+    static NINE = 57;
+    static FF_SEMICOLON = 59; // Firefox (Gecko) fires this for semicolon instead of 186
+    static FF_EQUALS = 61; // Firefox (Gecko) fires this for equals instead of 187
+    static QUESTION_MARK = 63;
+    static AT_SIGN = 64;
+    static A = 65;
+    static B = 66;
+    static C = 67;
+    static D = 68;
+    static E = 69;
+    static F = 70;
+    static G = 71;
+    static H = 72;
+    static I = 73;
+    static J = 74;
+    static K = 75;
+    static L = 76;
+    static M = 77;
+    static N = 78;
+    static O = 79;
+    static P = 80;
+    static Q = 81;
+    static R = 82;
+    static S = 83;
+    static T = 84;
+    static U = 85;
+    static V = 86;
+    static W = 87;
+    static X = 88;
+    static Y = 89;
+    static Z = 90;
+    static META = 91; // WIN_KEY_LEFT
+    static MAC_WK_CMD_LEFT = 91;
+    static MAC_WK_CMD_RIGHT = 93;
+    static CONTEXT_MENU = 93;
+    static NUMPAD_ZERO = 96;
+    static NUMPAD_ONE = 97;
+    static NUMPAD_TWO = 98;
+    static NUMPAD_THREE = 99;
+    static NUMPAD_FOUR = 100;
+    static NUMPAD_FIVE = 101;
+    static NUMPAD_SIX = 102;
+    static NUMPAD_SEVEN = 103;
+    static NUMPAD_EIGHT = 104;
+    static NUMPAD_NINE = 105;
+    static NUMPAD_MULTIPLY = 106;
+    static NUMPAD_PLUS = 107;
+    static NUMPAD_MINUS = 109;
+    static NUMPAD_PERIOD = 110;
+    static NUMPAD_DIVIDE = 111;
+    static F1 = 112;
+    static F2 = 113;
+    static F3 = 114;
+    static F4 = 115;
+    static F5 = 116;
+    static F6 = 117;
+    static F7 = 118;
+    static F8 = 119;
+    static F9 = 120;
+    static F10 = 121;
+    static F11 = 122;
+    static F12 = 123;
+    static NUM_LOCK = 144;
+    static SCROLL_LOCK = 145;
+    static FIRST_MEDIA = 166;
+    static FF_MINUS = 173;
+    static MUTE = 173; // Firefox (Gecko) fires 181 for MUTE
+    static VOLUME_DOWN = 174; // Firefox (Gecko) fires 182 for VOLUME_DOWN
+    static VOLUME_UP = 175; // Firefox (Gecko) fires 183 for VOLUME_UP
+    static FF_MUTE = 181;
+    static FF_VOLUME_DOWN = 182;
+    static LAST_MEDIA = 183;
+    static FF_VOLUME_UP = 183;
+    static SEMICOLON = 186; // Firefox (Gecko) fires 59 for SEMICOLON
+    static EQUALS = 187; // Firefox (Gecko) fires 61 for EQUALS
+    static COMMA = 188;
+    static DASH = 189; // Firefox (Gecko) fires 173 for DASH/MINUS
+    static PERIOD = 190;
+    static SLASH = 191;
+    static APOSTROPHE = 192;
+    static TILDE = 192;
+    static OPEN_SQUARE_BRACKET = 219;
+    static BACKSLASH = 220;
+    static CLOSE_SQUARE_BRACKET = 221;
+    static SINGLE_QUOTE = 222;
+    static MAC_META = 224;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const HttpParamsRequestInstance = (options, instance) => {
+    return new UtilsHttpParamsRequest(options, instance);
+};
+class UtilsHttpParamsRequest extends HttpParams {
+    params;
+    constructor(options, instance) {
+        super(options);
+        if (!instance) {
+            this.params = new HttpParams(options);
+            return;
+        }
+        if (instance instanceof UtilsHttpParamsRequest) {
+            this.params = instance.getInstance();
+            return;
+        }
+        if (instance instanceof HttpParams) {
+            this.params = instance;
+            return;
+        }
+    }
+    getInstance() {
+        return this.params;
+    }
+    setInstance(instance) {
+        if (instance instanceof UtilsHttpParamsRequest) {
+            this.params = instance.getInstance();
+            return;
+        }
+        if (instance instanceof HttpParams) {
+            this.params = instance;
+            return;
+        }
+    }
+    set(param, value) {
+        this.params = this.params.set(param, value);
+        return this;
+    }
+    has(param) {
+        return this.params.has(param);
+    }
+    get(param) {
+        return this.params.get(param);
+    }
+    getAll(param) {
+        return this.params.getAll(param);
+    }
+    keys() {
+        return this.params.keys();
+    }
+    append(param, value) {
+        this.params = this.params.append(param, value);
+        return this;
+    }
+    appendAll(params) {
+        this.params = this.params.appendAll(params);
+        return this;
+    }
+    delete(param, value) {
+        this.params = this.params.delete(param, value);
+        return this;
+    }
+    toString() {
+        return this.params.toString();
+    }
+}
+
+class UtilsLanguageConstants {
+    static VI = 'vi';
+    static EN = 'en';
+    static defaultLang = UtilsLanguageConstants.VI;
+}
+;
+
+const getKeyCacheByArrayObject = (keyCache, argumentsValue) => {
+    if (!keyCache || !argumentsValue) {
+        return '';
+    }
+    let keyBuild = `${JSON.stringify(argumentsValue.slice(1))}-key-cache-plus`;
+    if (argumentsValue && argumentsValue[0] instanceof HttpParams) {
+        const httpParams = argumentsValue[0];
+        const keys = argumentsValue[0].keys().sort((str1, str2) => str1.localeCompare(str2));
+        keys.forEach(key => {
+            keyBuild = `${keyBuild}${JSON.stringify(httpParams.get(key))}`;
+        });
+    }
+    const keyCachePlus = md5(keyBuild);
+    const keyCacheMD5 = md5(keyCache);
+    return `${keyCacheMD5}-${md5(`${keyCacheMD5}-${keyCachePlus}`)}`;
+};
+
+let functionCheck = () => {
+    return window.parent !== window.top;
+};
+const updateFunctionCheckEmbedFrame = (functionCustom) => {
+    functionCheck = functionCustom;
+};
+const isEmbedFrame = () => {
+    return functionCheck();
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class UtilsCommunicateMicro {
+    static KEY_GET_ALL_MESSAGE = 'MICRO_SITES_ALL_MESSAGE';
+    static PREFIX_TYPE = '3RD_INTEGRATE_MICRO_SITE_';
+    static initdEvent;
+    static subs = new Map();
+    static allMessageSub = new Subject();
+    static initEvent(currentWindow) {
+        if (this.initdEvent) {
+            return;
+        }
+        this.initdEvent = true;
+        if (!this.subs.get(UtilsCommunicateMicro.KEY_GET_ALL_MESSAGE)) {
+            this.subs.set(UtilsCommunicateMicro.KEY_GET_ALL_MESSAGE, UtilsCommunicateMicro.allMessageSub);
+        }
+        fromEvent(currentWindow, 'message').subscribe(e => {
+            const event = { data: { ...e.data } };
+            const data = event.data;
+            const type = data.type;
+            if (!type) {
+                return this.allMessageSub.next(event);
+            }
+            const sub = UtilsCommunicateMicro.GetMessage(type);
+            if (!type || !data.response) {
+                return;
+            }
+            try {
+                if (type.includes(UtilsCommunicateMicro.PREFIX_TYPE)) {
+                    data.response = JSON.parse(decrypt3rd(data.response));
+                    sub.next(event);
+                    this.allMessageSub.next(event);
+                    return;
+                }
+                data.response = JSON.parse(decrypt(data.response));
+                sub.next(event);
+                this.allMessageSub.next(event);
+            }
+            catch (error) {
+                console.log(error);
+                sub.next(event);
+                this.allMessageSub.next(event);
+            }
+        });
+    }
+    static PostMessageToParent(data) {
+        data = this.convertData(data);
+        try {
+            if (isEmbedFrame()) {
+                window?.parent?.postMessage(data, "*");
+                return;
+            }
+            window?.top?.postMessage(data, "*");
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    static PostMessageToChildren(data) {
+        data = this.convertData(data);
+        const iframes = document.querySelectorAll("iframe");
+        Array.from(iframes).forEach(iframe => {
+            iframe?.contentWindow?.postMessage(data, '*');
+        });
+    }
+    static PostMessageToOpener(data) {
+        if (!window.opener) {
+            return;
+        }
+        data = this.convertData(data);
+        window.opener.postMessage(data, '*');
+    }
+    static convertData(data) {
+        if (!data || !data.type || !data.response) {
+            return data;
+        }
+        data = { ...data };
+        const type = data.type;
+        if (type.includes(this.PREFIX_TYPE)) {
+            try {
+                JSON.parse(decrypt3rd(data.response));
+                return data;
+            }
+            catch (error) {
+                console.log(error);
+                data.response = decrypt3rd(JSON.stringify(data.response));
+                return data;
+            }
+        }
+        try {
+            JSON.parse(decrypt(data.response));
+            return data;
+        }
+        catch (error) {
+            console.log(error);
+            data.response = decrypt(JSON.stringify(data.response));
+            return data;
+        }
+    }
+    static GetMessage(messageType) {
+        if (!this.initdEvent) {
+            throw Error("chưa khơi tạo hàm lắng nghe sự kiện, gọi UtilsCommunicateMicro.initEvent(window) tại root component");
+        }
+        if (typeof messageType === 'string') {
+            let sub = this.subs.get(messageType);
+            if (!sub) {
+                sub = new Subject();
+                this.subs.set(messageType, sub);
+                return sub;
+            }
+            return sub;
+        }
+        if (!Array.isArray(messageType) || !messageType.length) {
+            throw new Error('message type empty');
+        }
+        const types = messageType.sort().join(';');
+        let sub = this.subs.get(types);
+        if (sub) {
+            return sub;
+        }
+        sub = new Subject();
+        this.subs.set(types, sub);
+        this.initSubject(sub, messageType);
+        return sub;
+    }
+    static initSubject(subRoot, messageType) {
+        messageType.forEach(key => {
+            this.GetMessage(key).subscribe(e => {
+                subRoot.next(e);
+            });
+        });
+    }
+    postMessageToParent(data) {
+        UtilsCommunicateMicro.PostMessageToParent(data);
+    }
+    postMessageToChildren(data) {
+        UtilsCommunicateMicro.PostMessageToChildren(data);
+    }
+}
+
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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);
+            }
+        });
+    }
+}
+
+const formatNumber = (value) => {
+    const lang = UtilsCache.getLang();
+    if (lang === UtilsLanguageConstants.EN) {
+        return `${value}`.replace(/[,]/g, '');
+    }
+    return `${value}`.replace(/[.]/g, '').replace(/[,]/g, '.');
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const viewDataNumberByLanguage = (value, acceptNegativeValue, parseFixed = 1, ignoreFormatSeparator = false, ignoreParseFloat = false) => {
+    const lang = UtilsCache.getLang();
+    if (!`${value}`.trim()) {
+        return '';
+    }
+    if (isNil(value) || (!acceptNegativeValue && +value <= 0)) {
+        return 0;
+    }
+    if (typeof value === 'string' && !ignoreFormatSeparator) {
+        value = formatNumber(value);
+    }
+    const isFloat = value.toString().includes('.');
+    const [intStr, floatStr] = value.toString().split('.');
+    if (!floatStr?.length) {
+        parseFixed = 0;
+    }
+    const round = (value, parseFixed) => {
+        const fixed = Math.pow(10, parseFixed);
+        return Math.round(value * fixed) / fixed;
+    };
+    if (parseFixed > (floatStr?.length || 0)) {
+        const maxParseFixed = (acceptNegativeValue && +value < 0) ? 17 : 16;
+        const fixed = maxParseFixed - (intStr?.length || 0);
+        parseFixed = parseFixed < fixed ? parseFixed : fixed;
+    }
+    if (isFloat && !ignoreParseFloat) {
+        value = parseFloat(round(+value, parseFixed).toFixed(parseFixed));
+    }
+    // Xử lý không format dữ liệu phần thập phân
+    const valueString = value.toString();
+    const index = valueString.indexOf('.');
+    if (index !== -1 && (parseFixed > 3 || ignoreParseFloat)) {
+        let decimalPart = valueString.substring(index + 1, valueString.length);
+        let int = valueString.substring(0, index + 1);
+        if (ignoreParseFloat) {
+            decimalPart = decimalPart.substring(0, parseFixed);
+        }
+        if (lang === UtilsLanguageConstants.EN) {
+            int = int.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+            return `${int}${decimalPart}`;
+        }
+        int = int.replace('.', ',').replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+        return `${int}${decimalPart}`;
+    }
+    if (index === -1 || parseFixed <= 3) {
+        if (lang === UtilsLanguageConstants.EN) {
+            return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+        }
+        return value.toString().replace('.', ',').replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+    }
+};
+
+const emojiPattern = () => {
+    return /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/g;
+};
+const removeEmoji = (text) => {
+    if (!text || !text.trim()) {
+        return text;
+    }
+    return text.replace(emojiPattern(), '');
+};
+
+const escapeHtml = (data) => {
+    if (!data || typeof data !== 'string') {
+        return data;
+    }
+    return data
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+};
+
+const deleteUnicode = (str) => {
+    str = str.replace(/à|á|ạ|ả|ã|â|ầ|ấ|ậ|ẩ|ẫ|ă|ằ|ắ|ặ|ẳ|ẵ/g, 'a');
+    str = str.replace(/è|é|ẹ|ẻ|ẽ|ê|ề|ế|ệ|ể|ễ|ễ/g, 'e');
+    str = str.replace(/ì|í|ị|ỉ|ĩ/g, 'i');
+    str = str.replace(/ò|ó|ọ|ỏ|õ|ô|ồ|ố|ộ|ổ|ỗ|ơ|ờ|ớ|ợ|ở|ỡ/g, 'o');
+    str = str.replace(/ù|ú|ụ|ủ|ũ|ư|ừ|ứ|ự|ử|ữ/g, 'u');
+    str = str.replace(/ỳ|ý|ỵ|ỷ|ỹ/g, 'y');
+    str = str.replace(/đ/g, 'd');
+    str = str.replace(/À|Á|Ạ|Ả|Ã|Â|Ầ|Ấ|Ậ|Ẩ|Ẫ|Ă|Ằ|Ắ|Ặ|Ẳ|Ẵ/g, 'A');
+    str = str.replace(/È|É|Ẹ|Ẻ|Ẽ|Ê|Ề|Ế|Ệ|Ể|Ễ/g, 'E');
+    str = str.replace(/Ì|Í|Ị|Ỉ|Ĩ/g, 'I');
+    str = str.replace(/Ò|Ó|Ọ|Ỏ|Õ|Ô|Ồ|Ố|Ộ|Ổ|Ỗ|Ơ|Ờ|Ớ|Ợ|Ở|Ỡ/g, 'O');
+    str = str.replace(/Ù|Ú|Ụ|Ủ|Ũ|Ư|Ừ|Ứ|Ự|Ử|Ữ/g, 'U');
+    str = str.replace(/Ỳ|Ý|Ỵ|Ỷ|Ỹ/g, 'Y');
+    str = str.replace(/Đ/g, 'D');
+    str = str.replace(/\u0300|\u0301|\u0303|\u0309|\u0323/g, ""); // ̀ ́ ̃ ̉ ̣  huyền, sắc, ngã, hỏi, nặng
+    str = str.replace(/\u02C6|\u0306|\u031B/g, ""); // ˆ ̆ ̛  Â, Ê, Ă, Ơ, Ư
+    return str.normalize();
+};
+
+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'
+];
+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];
+};
+
+const ERROR_MESSAGE_EMPTY_VALID = 'i18n_valid_empty_message';
+const ERROR_MESSAGE_PATTEN_VALID = 'i18n_valid_pattern_message';
+const ERROR_MESSAGE_MIN_VALID = 'i18n_message_error_input_min_value';
+const ERROR_MESSAGE_MAX_VALID = 'i18n_message_error_input_max_value';
+const ERROR_MESSAGE_MIN_LENGTH = 'i18n_message_error_input_min_length';
+const ERROR_MESSAGE_MAX_LENGTH = 'i18n_message_error_input_max_length';
+const CHARACTER_DATA_EMPTY = '__';
+
+/* eslint-disable no-useless-escape */
+const PATTERN_EMAIL = () => {
+    return /^[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]@[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]\.[A-z0-9]+[A-z0-9\_\.\+\-]*[A-z0-9]$/;
+};
+const PATTERN_URL = () => {
+    return /^(http|https|ftp):(\/){2}[^\s]+[.]{1}[^\s]+$/;
+};
+const PATTERN_HOST_URL = () => {
+    return /^((https|http|ftp):[/]{2}[^/\s]+)/;
+};
+const PATTERN_DOMAIN = () => {
+    return /^([a-zA-Z0-9])(([a-z0-9-]{1,61})?[a-z0-9]{1})?(\.[a-z0-9](([a-z0-9-]{1,61})?[a-z0-9]{1})?)?(\.[a-zA-Z]{2,4})+$/;
+};
+const PATTERN_MOBILE_PHONE = () => {
+    return /^(\+?84|0|84)([0-9]{9})$/;
+};
+const PATTERN_PHONE = () => {
+    return /^(\+?84|[0-9]|84)([0-9]{2,9})$/;
+};
+const PATTERN_PHONE_NORMAL = () => {
+    return /^(\+?84|[0-9]|84)([0-9]{9,10})$/;
+};
+const PATTERN_NUMBER = () => {
+    return /\d+/g;
+};
+const PATTERN_ENCODE_URI = () => {
+    return /%([0-9A-F]{2})/g;
+};
+const PATTERN_NAME = () => {
+    return /^\w+[A-Za-z\s\d]+$/;
+};
+const PATTERN_NAME_UTF8 = () => {
+    return /^[ àáảãạăắằẵặẳâầấậẫẩđèéẻẽẹêềếểễệìíỉĩịòóỏõọôồốổỗộơờớởỡợùúủũụưừứửữựỳýỷỹÀÁẢÃẠĂẮẰẴẶẲÂẦẤẬẪẨĐÈÉẺẼẸÊỀẾỂỄỆÌÍỈĨỊÒÓỎÕỌÔỒỐỔỖỘƠỜỚỞỠỢÙÚỦŨỤƯỪỨỬỮỰỲÝỶỸA-Za-z0-9]+$/;
+};
+const PATTERN_NAME_SPECIAL = () => {
+    return /[~!@#$%^&*()-+=<>,?\/\\:;"']/;
+};
+const PATTERN_NAME_PROFILE = () => {
+    return /([\w\W\d\s]+)+/;
+};
+const PATTERN_EMOJI = () => {
+    return /(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/g;
+};
+const PATTERN_RULE_FIELD_REPLACE = () => {
+    return /[{]{2}[a-zA-Z_-]+[}]{2}/g;
+};
+const PATTERN_GET_FIELD_BY_RULE_FIELD_REPLACE = () => {
+    return /[a-zA-Z_-]+/g;
+};
+const PATTERN_PEM = () => {
+    return /^(0|1):([0-9]{1,2}):(\{\{path-api\}\}):([a-zA-Z0-9\/]+)$/g;
+};
+const PATTERN_TAX = () => {
+    return /^([0-9]){10}(-[0-9]{3})?$/;
+};
+const PATTERN_KEY = () => {
+    return /^([0-9]){10}(-[0-9]{3})?$/;
+};
+const PATTERN_ACCOUNT = () => {
+    return /^(?=.*@)[a-z0-9@._-]{2,63}$/;
+};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CHARACTER_DATA_EMPTY, ERROR_MESSAGE_EMPTY_VALID, ERROR_MESSAGE_MAX_LENGTH, ERROR_MESSAGE_MAX_VALID, ERROR_MESSAGE_MIN_LENGTH, ERROR_MESSAGE_MIN_VALID, ERROR_MESSAGE_PATTEN_VALID, GetColorById, HttpParamsRequestInstance, PATTERN_ACCOUNT, PATTERN_DOMAIN, PATTERN_EMAIL, PATTERN_EMOJI, PATTERN_ENCODE_URI, PATTERN_GET_FIELD_BY_RULE_FIELD_REPLACE, PATTERN_HOST_URL, PATTERN_KEY, PATTERN_MOBILE_PHONE, PATTERN_NAME, PATTERN_NAME_PROFILE, PATTERN_NAME_SPECIAL, PATTERN_NAME_UTF8, PATTERN_NUMBER, PATTERN_PEM, PATTERN_PHONE, PATTERN_PHONE_NORMAL, PATTERN_RULE_FIELD_REPLACE, PATTERN_TAX, PATTERN_URL, UtilsCache, UtilsCommunicateMicro, UtilsHttpParamsRequest, UtilsKeyCodeConstant, UtilsLanguageConstants, UtilsUrlSearchParams, checkMouseOverInContainer, checkViewInScreen, cloneDeep, cloneIBoundingClientRect, colorContrastFromOrigin, colorStepContrastFromOrigin, decrypt, decrypt3rd, deleteUnicode, emojiPattern, encrypt, encrypt3rd, escapeHtml, formatNumber, generateInterface, get, getColorById, getKeyCacheByArrayObject, getPlatFromBrowser, getViewport, isEmbedFrame, isEmpty, isNil, listColorDefine$1 as listColorDefine, md5, removeEmoji, rgbToHex, set, setCaretPosition, setKeyCrypto, setKeyCrypto3rd, setStyles, updateFunctionCheckEmbedFrame, uuid, viewDataNumberByLanguage };
+//# sourceMappingURL=libs-ui-utils.mjs.map