@libs-ui/utils 0.1.1-1

package/format-text.d.ts

@@ -0,0 +1,11 @@
+import { ITextFormatOptions } from '@libs-ui/interfaces-types';
+export declare const highlightByKeyword: (value: string | undefined, search: string | undefined, ignoreHighlight?: boolean, classHightLight?: string) => string;
+export declare const formatTextCompare: (text: string, options?: ITextFormatOptions) => string;
+export declare const fullNameFormat: (value: string) => string;
+export declare const capitalize: (text: string, options?: ITextFormatOptions) => string;
+export declare const firstLetterToUpperCase: (text: string, options?: ITextFormatOptions) => string;
+export declare const uppercaseByPosition: (text: string, position: number, options?: ITextFormatOptions) => string;
+export declare const escapeHtml: (str: string) => string;
+export declare const decodeEscapeHtml: (str: string) => string;
+export declare const deleteUnicode: (str: string) => string;
+export declare const removeEmoji: (text: string) => string;

package/function-check-embed-frame.d.ts

@@ -0,0 +1,2 @@
+export declare const updateFunctionCheckEmbedFrame: (functionCustom: () => boolean) => void;
+export declare const isEmbedFrame: () => boolean;

package/get-smart-axis-scale.d.ts

@@ -0,0 +1,34 @@
+interface AxisScaleOptions {
+    minTickCount?: number;
+    maxTickCount?: number;
+    stepCandidates?: number[];
+    acceptNegative?: boolean;
+    minNegative?: number;
+    acceptStepIsTypeFloat?: boolean;
+}
+interface AxisScaleResult {
+    stepSize: number;
+    max: number;
+    min: number;
+    tickAmount: number;
+}
+/**
+ * Tính toán smart axis scale cho biểu đồ
+ *
+ * @param maxData - Giá trị tối đa của dữ liệu
+ * @param options - Các tùy chọn cấu hình axis scale
+ * @returns Cấu hình axis scale bao gồm stepSize, max, min, tickAmount
+ *
+ * @throws {Error} INVALID_NEGATIVE_DATA - khi maxData < 0 mà acceptNegative = false
+ * @throws {Error} MISSING_MIN_NEGATIVE - khi acceptNegative = true nhưng thiếu minNegative
+ * @throws {Error} INVALID_RANGE - khi maxData < minNegative
+ * @throws {Error} INVALID_MIN_NEGATIVE - khi minNegative >= 0
+ *
+ * @example
+ * ```typescript
+ * const result = getSmartAxisScale(100, { minTickCount: 5, maxTickCount: 10 });
+ * // returns { stepSize: 20, max: 120, min: 0, tickAmount: 6 }
+ * ```
+ */
+export declare const getSmartAxisScale: (originalMaxData: number, options?: AxisScaleOptions) => AxisScaleResult;
+export {};

package/helpers.d.ts

@@ -0,0 +1,270 @@
+import { Signal } from '@angular/core';
+import { GetReturnType, GetValueAtPath, PathOf, TYPE_OBJECT } from '@libs-ui/interfaces-types';
+/**Các hàm tương tự thư viện lodash */
+/**
+ * Kiểm tra xem một giá trị có phải là null hoặc undefined hay không
+ * @param value Giá trị cần kiểm tra
+ * @returns true nếu giá trị là null hoặc undefined, false nếu không
+ * @example
+ * isNil(null); // true
+ * isNil(undefined); // true
+ * isNil(0); // false
+ * isNil('hello'); // false
+ */
+export declare const isNil: (value: unknown, options?: {
+    ignoreUnWrapSignal?: boolean;
+}) => value is null | undefined;
+/**
+ * Kiểm tra xem một giá trị có phải là rỗng hay không
+ * @param value Giá trị cần kiểm tra
+ * @returns true nếu giá trị là null, rỗng hoặc undefined, false nếu không
+ * @example
+ * isEmpty(null); // true
+ * isEmpty(''); // true
+ * isEmpty(undefined); // true
+ * isEmpty({}); // true
+ * isEmpty([]); // true
+ * isEmpty([1, 2, 3]); // false
+ * isEmpty({ a: 1 }); // false
+ */
+export declare const isEmpty: (value: any, options?: {
+    ignoreCheckTypePrimitive?: boolean;
+    ignoreUnWrapSignal?: boolean;
+    ignoreCheckString?: boolean;
+}) => value is null | undefined | "" | 0;
+/**
+ * Kiểm tra xem một giá trị có phải là null, rỗng, undefined hoặc 0 hay không
+ * @param value Giá trị cần kiểm tra
+ * @param options Cấu hình tùy chọn
+ * @param options.ignoreZero Nếu true, sẽ không kiểm tra giá trị 0
+ * @returns true nếu giá trị là null, rỗng, undefined hoặc 0, false nếu không
+ * @example
+ * isTruthy(null); // false
+ * isTruthy(''); // false
+ * isTruthy(undefined); // false
+ * isTruthy(0); // false
+ * isTruthy({}); // true
+ * isTruthy(0, { ignoreZero: true }); // true
+ */
+export declare const isTruthy: <T>(value: T, options?: {
+    ignoreZero?: boolean;
+    ignoreCheckString?: boolean;
+    ignoreUnWrapSignal?: boolean;
+}) => value is NonNullable<T>;
+/**
+ * Kiểm tra xem một giá trị có phải là null, rỗng, undefined hoặc 0 hay không
+ * @param value Giá trị cần kiểm tra
+ * @param options Cấu hình tùy chọn
+ * @param options.ignoreZero Nếu true, sẽ không kiểm tra giá trị 0
+ * @returns true nếu giá trị là null, rỗng, undefined hoặc 0, false nếu không
+ * @example
+ * isFalsy(null); // true
+ * isFalsy(''); // true
+ * isFalsy(undefined); // true
+ * isFalsy(0); // true
+ * isFalsy({}); // false
+ * isFalsy(0, { ignoreZero: true }); // false
+ */
+export declare const isFalsy: (value: unknown, options?: {
+    ignoreZero?: boolean;
+    ignoreCheckString?: boolean;
+    ignoreUnWrapSignal?: boolean;
+}) => value is null | undefined | "" | 0;
+/**
+ * Loại bỏ các thuộc tính của đối tượng dựa trên một hàm điều kiện
+ * @param objData Đối tượng cần xử lý
+ * @param predicate Hàm điều kiện để kiểm tra giá trị của thuộc tính. Nếu hàm trả về true thì thuộc tính đó sẽ bị loại bỏ
+ * @returns Đối tượng mới sau khi đã loại bỏ các thuộc tính thỏa mãn điều kiện
+ * @example
+ * const obj = { a: 1, b: null, c: 3, d: undefined };
+ * omitBy(obj, isNil); // { a: 1, c: 3 }
+ */
+export declare const omitBy: <T>(objData: Record<string, any>, predicate: (val: any) => boolean) => T;
+/**
+ * Lấy giá trị từ đối tượng theo đường dẫn chỉ định
+ *
+ * Hàm này giúp bạn truy cập vào các thuộc tính sâu bên trong một đối tượng một cách an toàn,
+ * tránh lỗi khi thuộc tính không tồn tại.
+ *
+ * @param obj Đối tượng nguồn cần lấy giá trị
+ * @param path Đường dẫn đến thuộc tính cần lấy. Có thể là:
+ *   - Chuỗi: 'user.profile.name' hoặc 'items[0].title'
+ *   - Mảng: ['user', 'profile', 'name'] hoặc ['items', '0', 'title']
+ *   - Chuỗi rỗng '': trả về chính đối tượng gốc
+ * @param defaultValue Giá trị mặc định trả về khi không tìm thấy thuộc tính (mặc định: undefined)
+ * @param keepLastValueIfSignal Có giữ nguyên signal cuối cùng hay không (mặc định: false - sẽ gọi signal())
+ * @returns Giá trị tìm được hoặc giá trị mặc định
+ *
+ * @example
+ * // Ví dụ cơ bản
+ * const user = { name: 'John', age: 30 };
+ * get(user, 'name'); // 'John'
+ * get(user, 'email'); // undefined
+ * get(user, 'email', 'no-email'); // 'no-email'
+ *
+ * @example
+ * // Truyền path rỗng - trả về chính đối tượng gốc
+ * const data = { name: 'Alice', age: 25 };
+ * get(data, ''); // { name: 'Alice', age: 25 } (chính đối tượng data)
+ * get(data, '', 'default'); // { name: 'Alice', age: 25 } (bỏ qua defaultValue)
+ *
+ * @example
+ * // Truy cập thuộc tính sâu
+ * const data = {
+ *   user: {
+ *     profile: {
+ *       name: 'Alice',
+ *       settings: { theme: 'dark' }
+ *     }
+ *   }
+ * };
+ * get(data, 'user.profile.name'); // 'Alice'
+ * get(data, 'user.profile.settings.theme'); // 'dark'
+ * get(data, 'user.profile.avatar', 'default.jpg'); // 'default.jpg'
+ *
+ * @example
+ * // Truy cập mảng
+ * const items = [
+ *   { name: 'Item 1', price: 100 },
+ *   { name: 'Item 2', price: 200 }
+ * ];
+ * get(items, '[0].name'); // 'Item 1'
+ * get(items, '[1].name'); // 'Item 2'
+ * get(items, '[2].name', 'Not found'); // 'Not found'
+ *
+ * @example
+ * // Sử dụng với mảng path
+ * const nested = { a: { b: { c: 'deep value' } } };
+ * get(nested, ['a', 'b', 'c']); // 'deep value'
+ * get(nested, ['a', 'b', 'd'], 'default'); // 'default'
+ *
+ * @example
+ * // Trường hợp đặc biệt
+ * get(null, 'any.path'); // undefined
+ * get(undefined, 'any.path', 'fallback'); // 'fallback'
+ */
+export declare const get: <O, P extends PathOf<O> = PathOf<O>, KS extends boolean = false, D extends GetValueAtPath<O, P, KS> | undefined = undefined>(obj: Signal<O> | O, path: P, defaultValue?: D, keepLastValueIfSignal?: KS) => GetReturnType<O, P, KS, D>;
+/**
+ * Thiết lập giá trị cho một thuộc tính trong đối tượng theo đường dẫn chỉ định
+ * @param obj Đối tượng cần thiết lập giá trị
+ * @param path Đường dẫn đến thuộc tính, có thể là chuỗi (vd: 'a.b.c') hoặc mảng (vd: ['a', 'b', 'c'])
+ * @param value Giá trị cần thiết lập
+ * @returns Đối tượng sau khi đã thiết lập giá trị
+ * @throws Error nếu tham số đầu tiên không phải là đối tượng
+ * @example
+ * const obj = { a: { b: 1 } };
+ * set(obj, 'a.b', 2); // { a: { b: 2 } }
+ */
+export declare const set: <O, P extends PathOf<O> = PathOf<O>, T extends GetValueAtPath<O, P, true> = GetValueAtPath<O, P, true>>(obj: Signal<O> | O, path: P, value: T, options?: {
+    valueDefaultPathObjectUndefined?: any;
+    valueDefaultPathArrayUndefined?: any;
+}) => O;
+/**
+ * Tạo một bản sao sâu của một đối tượng hoặc giá trị bất kỳ
+ * @param data Dữ liệu cần sao chép
+ * @param options Tùy chọn cấu hình
+ * @param options.ignoreSignal Nếu true, sẽ không sao chép các signal mà trả về signal gốc
+ * @param seen WeakMap để theo dõi các tham chiếu đã được sao chép, tránh lặp vô hạn với các tham chiếu vòng
+ * @returns Bản sao sâu của dữ liệu đầu vào
+ * @example
+ * const obj = {
+ *   a: 1,
+ *   b: { c: 2 },
+ *   d: [1, 2, 3]
+ * };
+ * const clone = cloneDeep(obj);
+ * // clone là một bản sao hoàn toàn độc lập của obj
+ */
+export declare const cloneDeep: <T = any>(data: any, options?: {
+    ignoreSignal: boolean;
+}, seen?: WeakMap<object, any>) => T;
+/**
+ * Chuyển đổi một mảng các đối tượng thành một đối tượng với khóa được chỉ định
+ * @param data Mảng các đối tượng cần chuyển đổi
+ * @param key Tên thuộc tính được sử dụng làm khóa trong đối tượng kết quả
+ * @returns Đối tượng với các giá trị từ mảng được đánh key theo thuộc tính đã chỉ định
+ * @example
+ * const data = [
+ *   { id: 1, name: 'John' },
+ *   { id: 2, name: 'Jane' }
+ * ];
+ * keyBy(data, 'id');
+ * // Kết quả: {
+ * //   '1': { id: 1, name: 'John' },
+ * //   '2': { id: 2, name: 'Jane' }
+ * // }
+ */
+export declare const keyBy: (data: Array<TYPE_OBJECT>, key: string) => TYPE_OBJECT;
+/**
+ * Nhóm các đối tượng trong một mảng thành các nhóm dựa trên một thuộc tính cụ thể
+ * @param data Mảng các đối tượng cần nhóm
+ * @param key Tên thuộc tính được sử dụng làm khóa nhóm
+ * @returns Đối tượng với các giá trị từ mảng được nhóm theo thuộc tính đã chỉ định
+ * @example
+ * const data = [
+ *   { id: 1, name: 'John' },
+ *   { id: 2, name: 'Jane' },
+ *   { id: 1, name: 'John' }
+ * ];
+ * groupBy(data, 'id');
+ * // Kết quả: {
+ * //   '1': [
+ * //     { id: 1, name: 'John' },
+ * //     { id: 1, name: 'John' }
+ * //   ],
+ * //   '2': [
+ * //     { id: 2, name: 'Jane' }
+ * // }
+ */
+export declare const groupBy: (data: Array<TYPE_OBJECT>, key: string) => TYPE_OBJECT;
+/**
+ * Tạo một mảng các số từ giá trị bắt đầu đến giá trị kết thúc với bước nhảy tùy chọn
+ * @param start Giá trị bắt đầu của dãy số. Nếu chỉ có một tham số, đây sẽ là giá trị kết thúc và giá trị bắt đầu sẽ là 0
+ * @param end Giá trị kết thúc của dãy số (tùy chọn)
+ * @param step Bước nhảy giữa các số trong dãy (tùy chọn). Mặc định là 1 nếu end > start, -1 nếu end < start
+ * @returns Mảng các số từ start đến end với bước nhảy step
+ * @example
+ * range(4);      // [0, 1, 2, 3]
+ * range(1, 5);   // [1, 2, 3, 4]
+ * range(0, 20, 5); // [0, 5, 10, 15]
+ * range(5, 2);   // [5, 4, 3]
+ */
+export declare const range: (start: number, end?: number, step?: number) => Array<number>;
+/**
+ * So sánh hai giá trị bất kỳ có bằng nhau hay không
+ * @param value1 Giá trị thứ nhất cần so sánh
+ * @param value2 Giá trị thứ hai cần so sánh
+ * @param exactlyPosition Có so sánh chính xác vị trí các phần tử trong mảng hay không
+ * @returns true nếu hai giá trị bằng nhau, false nếu không bằng nhau
+ * @example
+ * isEqual([1,2,3], [1,2,3]); // true
+ * isEqual([1,2,3], [3,2,1]); // true khi exactlyPosition = false
+ * isEqual([1,2,3], [3,2,1]); // false khi exactlyPosition = true
+ * isEqual({a:1}, {a:1}); // true
+ */
+export declare const isEqual: (value1: any, value2: any, options?: {
+    exactlyPosition?: boolean;
+    ignoreExactlyDataType?: boolean;
+    ignoreUnWrapSignal?: boolean;
+}) => boolean;
+/**
+ * Loại bỏ các phần tử trùng lặp trong mảng dựa trên một thuộc tính chỉ định
+ * @param data Mảng dữ liệu cần xử lý
+ * @param key Tên thuộc tính dùng để so sánh trùng lặp. Nếu không có key thì so sánh trực tiếp giá trị
+ * @returns Mảng mới chứa các phần tử không trùng lặp
+ * @example
+ * const arr = [
+ *   { id: 1, name: 'A' },
+ *   { id: 2, name: 'B' },
+ *   { id: 1, name: 'C' }
+ * ];
+ * uniqBy(arr, 'id'); // [{ id: 1, name: 'A' }, { id: 2, name: 'B' }]
+ *
+ * const numbers = [1, 2, 2, 3, 3];
+ * uniqBy(numbers); // [1, 2, 3]
+ *
+ * const numbersSignal = [signal(1), signal(2), signal(3), signal(2), signal(5), signal(4), signal(1), signal(6), signal(7), signal(6)];
+ * uniqBy(numbersSignal); // [signal(1), signal(2), signal(3), signal(5), signal(4), signal(6), signal(7)]
+ */
+export declare const uniqBy: <T>(data: Array<T>, key?: string) => Array<T>;
+export declare const generateInterface: (obj: any, interfaceName: string) => string;

package/http-params.d.ts

@@ -0,0 +1,37 @@
+import { HttpParameterCodec, HttpParams } from '@angular/common/http';
+export declare const UtilsHttpParamsRequestInstance: <Type>(options?: HttpParamsOptions<Type>, instance?: HttpParams) => UtilsHttpParamsRequest<Type>;
+export declare class UtilsHttpParamsRequest<Type = {
+    pem: string;
+}> extends HttpParams {
+    protected params: HttpParams;
+    constructor(options?: HttpParamsOptions<Type>, instance?: HttpParams);
+    getInstance(): HttpParams;
+    setInstance(instance: HttpParams): void;
+    set(param: string, value: string | number | boolean): UtilsHttpParamsRequest;
+    has(param: string): boolean;
+    get(param: string): string | null;
+    getAll(param: string): string[] | null;
+    keys(): string[];
+    append(param: string, value: string | number | boolean): HttpParams;
+    appendAll(params: {
+        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+    }): HttpParams;
+    delete(param: string, value?: string | number | boolean): UtilsHttpParamsRequest;
+    toString(): string;
+}
+export declare interface HttpParamsOptions<Type> {
+    fromString?: string;
+    fromObject?: TYPE_FROM_OBJECT<Type>;
+    encoder?: HttpParameterCodec;
+}
+export type GET_PATH_VARIABLE<TypePath, TypeOther = unknown> = {
+    [Property in keyof TypePath as `pathVariable-${Lowercase<string & Property>}`]: TypePath[Property];
+} & TypeOther;
+type TYPE_FROM_OBJECT<Type> = Type extends undefined | null ? {
+    pem: string;
+} : {
+    pem?: string;
+} & {
+    [Property in keyof Type]?: Type[Property];
+};
+export {};

package/index.d.ts

@@ -0,0 +1,29 @@
+export * from './dom';
+export * from './url-search-params';
+export * from './uuid';
+export * from './helpers';
+export * from './color';
+export * from './crypto';
+export * from './crypto-3rd';
+export * from './key-code';
+export * from './http-params';
+export * from './language';
+export * from './key-cache';
+export * from './cache';
+export * from './format-number';
+export * from './communicate-micro';
+export * from './function-check-embed-frame';
+export * from './constants';
+export * from './pattern';
+export * from './xss-filter';
+export * from './two-way-signal-object';
+export * from './date';
+export * from './download';
+export * from './base64';
+export * from './inject-token';
+export * from './file';
+export * from './uri';
+export * from './format-text';
+export * from './get-smart-axis-scale';
+export * from './random';
+export * from './dangerous-object';

package/inject-token.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+export declare const LINK_IMAGE_ERROR_TOKEN_INJECT: InjectionToken<string>;
+export declare const PROCESS_BAR_STANDARD_CONFIG_DEFAULT_TOKEN_INJECT: InjectionToken<string>;
+export declare const PROCESS_BAR_STEPS_CONFIG_DEFAULT_TOKEN_INJECT: InjectionToken<string>;

package/key-cache.d.ts

@@ -0,0 +1 @@
+export declare const getKeyCacheByArrayObject: (keyCache: string, argumentsValue?: Array<unknown>) => string;

package/key-code.d.ts

@@ -0,0 +1,122 @@
+export declare abstract class UtilsKeyCodeConstant {
+    static readonly MAC_ENTER = 3;
+    static readonly BACKSPACE = 8;
+    static readonly TAB = 9;
+    static readonly NUM_CENTER = 12;
+    static readonly ENTER = 13;
+    static readonly SHIFT = 16;
+    static readonly CONTROL = 17;
+    static readonly ALT = 18;
+    static readonly PAUSE = 19;
+    static readonly CAPS_LOCK = 20;
+    static readonly ESCAPE = 27;
+    static readonly SPACE = 32;
+    static readonly PAGE_UP = 33;
+    static readonly PAGE_DOWN = 34;
+    static readonly END = 35;
+    static readonly HOME = 36;
+    static readonly LEFT_ARROW = 37;
+    static readonly UP_ARROW = 38;
+    static readonly RIGHT_ARROW = 39;
+    static readonly DOWN_ARROW = 40;
+    static readonly PLUS_SIGN = 43;
+    static readonly PRINT_SCREEN = 44;
+    static readonly INSERT = 45;
+    static readonly DELETE = 46;
+    static readonly ZERO = 48;
+    static readonly ONE = 49;
+    static readonly TWO = 50;
+    static readonly THREE = 51;
+    static readonly FOUR = 52;
+    static readonly FIVE = 53;
+    static readonly SIX = 54;
+    static readonly SEVEN = 55;
+    static readonly EIGHT = 56;
+    static readonly NINE = 57;
+    static readonly FF_SEMICOLON = 59;
+    static readonly FF_EQUALS = 61;
+    static readonly QUESTION_MARK = 63;
+    static readonly AT_SIGN = 64;
+    static readonly A = 65;
+    static readonly B = 66;
+    static readonly C = 67;
+    static readonly D = 68;
+    static readonly E = 69;
+    static readonly F = 70;
+    static readonly G = 71;
+    static readonly H = 72;
+    static readonly I = 73;
+    static readonly J = 74;
+    static readonly K = 75;
+    static readonly L = 76;
+    static readonly M = 77;
+    static readonly N = 78;
+    static readonly O = 79;
+    static readonly P = 80;
+    static readonly Q = 81;
+    static readonly R = 82;
+    static readonly S = 83;
+    static readonly T = 84;
+    static readonly U = 85;
+    static readonly V = 86;
+    static readonly W = 87;
+    static readonly X = 88;
+    static readonly Y = 89;
+    static readonly Z = 90;
+    static readonly META = 91;
+    static readonly MAC_WK_CMD_LEFT = 91;
+    static readonly MAC_WK_CMD_RIGHT = 93;
+    static readonly CONTEXT_MENU = 93;
+    static readonly NUMPAD_ZERO = 96;
+    static readonly NUMPAD_ONE = 97;
+    static readonly NUMPAD_TWO = 98;
+    static readonly NUMPAD_THREE = 99;
+    static readonly NUMPAD_FOUR = 100;
+    static readonly NUMPAD_FIVE = 101;
+    static readonly NUMPAD_SIX = 102;
+    static readonly NUMPAD_SEVEN = 103;
+    static readonly NUMPAD_EIGHT = 104;
+    static readonly NUMPAD_NINE = 105;
+    static readonly NUMPAD_MULTIPLY = 106;
+    static readonly NUMPAD_PLUS = 107;
+    static readonly NUMPAD_MINUS = 109;
+    static readonly NUMPAD_PERIOD = 110;
+    static readonly NUMPAD_DIVIDE = 111;
+    static readonly F1 = 112;
+    static readonly F2 = 113;
+    static readonly F3 = 114;
+    static readonly F4 = 115;
+    static readonly F5 = 116;
+    static readonly F6 = 117;
+    static readonly F7 = 118;
+    static readonly F8 = 119;
+    static readonly F9 = 120;
+    static readonly F10 = 121;
+    static readonly F11 = 122;
+    static readonly F12 = 123;
+    static readonly NUM_LOCK = 144;
+    static readonly SCROLL_LOCK = 145;
+    static readonly FIRST_MEDIA = 166;
+    static readonly FF_MINUS = 173;
+    static readonly MUTE = 173;
+    static readonly VOLUME_DOWN = 174;
+    static readonly VOLUME_UP = 175;
+    static readonly FF_MUTE = 181;
+    static readonly FF_VOLUME_DOWN = 182;
+    static readonly LAST_MEDIA = 183;
+    static readonly FF_VOLUME_UP = 183;
+    static readonly SEMICOLON = 186;
+    static readonly EQUALS = 187;
+    static readonly COMMA = 188;
+    static readonly DASH = 189;
+    static readonly PERIOD = 190;
+    static readonly SLASH = 191;
+    static readonly APOSTROPHE = 192;
+    static readonly TILDE = 192;
+    static readonly OPEN_SQUARE_BRACKET = 219;
+    static readonly BACKSLASH = 220;
+    static readonly CLOSE_SQUARE_BRACKET = 221;
+    static readonly SINGLE_QUOTE = 222;
+    static readonly MAC_META = 224;
+    static readonly BUFFERED = 229;
+}

package/language.d.ts

@@ -0,0 +1,37 @@
+export declare class UtilsLanguageConstants {
+    static VI: string;
+    static EN: string;
+    static FR: string;
+    static DE: string;
+    static ES: string;
+    static ZH: string;
+    static ZH_TW: string;
+    static JA: string;
+    static KO: string;
+    static RU: string;
+    static IT: string;
+    static PT: string;
+    static TH: string;
+    static ID: string;
+    static MS: string;
+    static AR: string;
+    static HI: string;
+    static BN: string;
+    static TR: string;
+    static NL: string;
+    static KM: string;
+    static LO: string;
+    static MY: string;
+    static TL: string;
+    static CEB: string;
+    static JV: string;
+    static SU: string;
+    static defaultLang: string;
+    static supportedLanguages: Set<string>;
+    /**
+     * Kiểm tra xem ngôn ngữ đầu vào có được hỗ trợ không
+     * @param lang Mã ngôn ngữ cần kiểm tra
+     * @returns True nếu được hỗ trợ, False nếu không
+     */
+    static isSupported(lang: string): boolean;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@libs-ui/utils",
+  "version": "0.1.1-1",
+  "peerDependencies": {
+    "@angular/common": ">=18.0.0",
+    "@angular/core": ">=18.0.0",
+    "crypto-es": "^2.1.0",
+    "dayjs": "1.11.5",
+    "@libs-ui/interfaces-types": "0.1.1-1",
+    "rxjs": "~7.8.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/libs-ui-utils.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/libs-ui-utils.mjs",
+      "esm": "./esm2022/libs-ui-utils.mjs",
+      "default": "./fesm2022/libs-ui-utils.mjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/pattern.d.ts

@@ -0,0 +1,20 @@
+export declare const patternEmail: () => RegExp;
+export declare const patternUrl: () => RegExp;
+export declare const patternHostUrl: () => RegExp;
+export declare const patternDomain: () => RegExp;
+export declare const patternMobilePhone: () => RegExp;
+export declare const patternPhone: () => RegExp;
+export declare const patternPhoneNormal: () => RegExp;
+export declare const patternNumber: () => RegExp;
+export declare const patternEncodeUri: () => RegExp;
+export declare const patternName: () => RegExp;
+export declare const patternNameUtf8: () => RegExp;
+export declare const patternNameSpecial: () => RegExp;
+export declare const patternNameProfile: () => RegExp;
+export declare const patternEmoji: () => RegExp;
+export declare const patternRuleFieldReplace: () => RegExp;
+export declare const patternGetFieldByRuleFieldReplace: () => RegExp;
+export declare const patternPem: () => RegExp;
+export declare const patternTax: () => RegExp;
+export declare const patternKey: () => RegExp;
+export declare const patternAccount: () => RegExp;

package/random.d.ts

@@ -0,0 +1,3 @@
+export declare const protectString: (input: string) => string;
+export declare const revealString: (encoded: string) => string;
+export declare const createUniqueRandomIntGenerator: (min: number, max: number) => () => number;

package/two-way-signal-object.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chuyển đổi một đối tượng hoặc giá trị thành signal
+ * @param data Dữ liệu cần chuyển đổi thành signal
+ * @param cloneDeepIfNotSignal Có thực hiện sao chép sâu dữ liệu trước khi chuyển đổi hay không nếu data không phải signal. Mặc định là true.
+ * Đặt false nếu muốn giữ nguyên tham chiếu đến dữ liệu gốc.
+ * Nếu muốn sao chép sâu đối tượng signal thì đặt cloneDeepIfNotSignal là true và acceptConvertObjectInnerWritableSignal là true.
+ * @param isSignalPrimitiveType Có chuyển đổi các giá trị nguyên thủy (string, number, boolean) thành signal hay không. Mặc định là false.
+ * Đặt true nếu muốn bọc các giá trị nguyên thủy trong signal.
+ * @param acceptConvertObjectInnerWritableSignal Có tiếp tục tìm kiếm và chuyển đổi các đối tượng bên trong signal hay không. Mặc định là false.
+ * Đặt true nếu muốn tìm và chuyển đổi các đối tượng bên trong signal hoặc chính nó thành signal mới.
+ * @returns Dữ liệu đã được chuyển đổi theo kiểu T
+ */
+export declare const convertObjectToSignal: <T = any>(data: any, cloneDeepIfNotSignal?: boolean, isSignalPrimitiveType?: boolean, acceptConvertObjectInnerWritableSignal?: boolean, seen?: WeakMap<object, any>) => T;
+export declare const convertSignalToObject: <T = any>(data: any, isCloneDeep?: boolean, seen?: WeakMap<object, any>) => T;
+export declare const unwrapSignal: (data: any) => any;

package/uri.d.ts

@@ -0,0 +1,5 @@
+import { TYPE_OBJECT } from '@libs-ui/interfaces-types';
+export declare const ENCODE_URI_PATTERN: RegExp;
+export declare const decodeURI: (value: string) => string;
+export declare const encodeURI: (value: string) => string;
+export declare const endCodeUrl: (params: TYPE_OBJECT, isBody: boolean) => string;

package/url-search-params.d.ts

@@ -0,0 +1,25 @@
+export declare class UtilsUrlSearchParams {
+    private static instance;
+    private params;
+    constructor(paramString: string);
+    static getInstance(): UtilsUrlSearchParams;
+    static toStringParamObject(params: {
+        [key in string]: string;
+    }): string;
+    static ToString(params: Array<{
+        key: string;
+        value: string;
+    }>): string;
+    private buildParams;
+    set(key: string, value: string): void;
+    get(key: string): string | undefined;
+    has(key: string): boolean;
+    delete(key: string): void;
+    length(): number;
+    toString(params?: Array<{
+        key: string;
+        value: string;
+    }>): string;
+    getParamObject(): Record<string, string>;
+    compareParams(param1: string, param2: string): boolean;
+}

package/uuid.d.ts

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

package/xss-filter.d.ts

@@ -0,0 +1,3 @@
+export type TYPE_FUNCTION_XSS = (data: string) => Promise<string>;
+export declare const updateFunctionXssFilter: (functionCustom: TYPE_FUNCTION_XSS) => void;
+export declare const xssFilter: TYPE_FUNCTION_XSS;