@libs-ui/utils 0.2.29 → 0.2.30-6.2

package/esm2022/format-text.mjs

@@ -0,0 +1,150 @@
+import { patternEmoji } from "./pattern";
+export const highlightByKeyword = (value, search, ignoreHighlight, classHightLight) => {
+    if (!value) {
+        return '—';
+    }
+    try {
+        if (!search || ignoreHighlight) {
+            return value;
+        }
+        const keysReplace = getValueReplace(search, value);
+        if (!keysReplace || !keysReplace.length) {
+            return value;
+        }
+        if (!classHightLight) {
+            classHightLight = 'bg-[#19344a] text-white';
+        }
+        keysReplace.forEach(key => {
+            const regExp = new RegExp(key, 'gi');
+            value = value?.replace(regExp, `<span class="${classHightLight}">$&</span>`);
+        });
+    }
+    catch (error) {
+        console.log(error);
+    }
+    finally {
+        // eslint-disable-next-line no-unsafe-finally
+        return value;
+    }
+};
+const getValueReplace = (search, value) => {
+    const searchConvert = deleteUnicode(search).toLowerCase();
+    const valueConvert = deleteUnicode(value).toLowerCase();
+    const keys = new Set();
+    let i = 0;
+    while ((i = valueConvert.indexOf(searchConvert, i)) >= 0) {
+        const endIndex = i + search.length;
+        keys.add(value.substring(i, endIndex));
+        i += +valueConvert.length;
+    }
+    return Array.from(keys);
+};
+export const formatTextCompare = (text, options) => {
+    if (!text) {
+        return text;
+    }
+    text = text.normalize("NFC");
+    return formatByOptions(text, options);
+};
+export const fullNameFormat = (value) => {
+    if (!value) {
+        return value;
+    }
+    return capitalize(value, { lowercaseOtherCharacter: true, trim: true, removeMultipleSpace: true, removeEmoji: true });
+};
+export const capitalize = (text, options) => {
+    if (!text) {
+        return text;
+    }
+    text = formatByOptions(text, options);
+    return text.split(' ').map(word => firstLetterToUpperCase(word)).join(' ');
+};
+export const firstLetterToUpperCase = (text, options) => {
+    if (!text) {
+        return text;
+    }
+    return uppercaseByPosition(text, 0, options);
+};
+export const uppercaseByPosition = (text, position, options) => {
+    if (!text) {
+        return text;
+    }
+    text = formatByOptions(text, options);
+    return `${text.substring(0, position)}${text.charAt(position).toUpperCase()}${text.substring(position + 1)}`;
+};
+const formatByOptions = (text, options) => {
+    if (!text || !options) {
+        return text;
+    }
+    if (options?.uppercaseOtherCharacter) {
+        text = text.toUpperCase();
+    }
+    if (options?.lowercaseOtherCharacter) {
+        text = text.toLowerCase();
+    }
+    if (options?.removeMultipleSpace) {
+        text = text.replace(/\u200B|\u00A0/g, "");
+        text = text.replace(/\s+/g, ' ');
+    }
+    if (options?.removeEmoji) {
+        text = removeEmoji(text);
+    }
+    if (options?.removeUnicode) {
+        text = deleteUnicode(text);
+    }
+    if (options?.trim) {
+        text = text.trim();
+    }
+    return text;
+};
+export const escapeHtml = (str) => {
+    if (!str || typeof str !== 'string') {
+        return str;
+    }
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+};
+export const decodeEscapeHtml = (str) => {
+    const htmlTag = document.createElement('textarea');
+    htmlTag.innerHTML = str;
+    while (str) {
+        if (str === htmlTag.value) {
+            str = htmlTag.value;
+            htmlTag.remove();
+            break;
+        }
+        str = htmlTag.value;
+        htmlTag.innerHTML = str;
+    }
+    return str;
+};
+export 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("NFC");
+};
+export const removeEmoji = (text) => {
+    if (!text || !text.trim()) {
+        return text;
+    }
+    return text.replace(patternEmoji(), '');
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format-text.js","sourceRoot":"","sources":["../../../../libs-ui/utils/src/format-text.ts"],"names":[],"mappings":"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","sourcesContent":["import { ITextFormatOptions } from \"@libs-ui/interfaces-types\";\nimport { patternEmoji } from \"./pattern\";\n\nexport const highlightByKeyword = (value: string | undefined, search: string | undefined, ignoreHighlight?: boolean, classHightLight?: string) => {\n\tif (!value) {\n\t\treturn '&mdash;';\n\t}\n\ttry {\n\t\tif (!search || ignoreHighlight) {\n\t\t\treturn value;\n\t\t}\n\t\tconst keysReplace: Array<string> = getValueReplace(search, value);\n\n\t\tif (!keysReplace || !keysReplace.length) {\n\t\t\treturn value;\n\t\t}\n\t\tif (!classHightLight) {\n\t\t\tclassHightLight = 'bg-[#19344a] text-white';\n\t\t}\n\t\tkeysReplace.forEach(key => {\n\t\t\tconst regExp = new RegExp(key, 'gi');\n\n\t\t\tvalue = value?.replace(regExp, `<span class=\"${classHightLight}\">$&</span>`);\n\t\t});\n\n\t} catch (error) {\n\t\tconsole.log(error);\n\t} finally {\n\t\t// eslint-disable-next-line no-unsafe-finally\n\t\treturn value;\n\t}\n}\n\n\nconst getValueReplace = (search: string, value: string): string[] => {\n\tconst searchConvert = deleteUnicode(search).toLowerCase();\n\tconst valueConvert = deleteUnicode(value).toLowerCase();\n\tconst keys: Set<string> = new Set();\n\tlet i = 0;\n\n\twhile ((i = valueConvert.indexOf(searchConvert, i)) >= 0) {\n\t\tconst endIndex = i + search.length;\n\n\t\tkeys.add(value.substring(i, endIndex));\n\t\ti += +valueConvert.length;\n\t}\n\n\treturn Array.from(keys);\n}\n\n\nexport const formatTextCompare = (text: string, options?: ITextFormatOptions) => {\n\tif (!text) {\n\t\treturn text;\n\t}\n\n\ttext = text.normalize(\"NFC\");\n\n\treturn formatByOptions(text, options);\n}\n\n\nexport const fullNameFormat = (value: string) => {\n\tif (!value) {\n\t\treturn value;\n\t}\n\treturn capitalize(value, { lowercaseOtherCharacter: true, trim: true, removeMultipleSpace: true, removeEmoji: true });\n};\n\nexport const capitalize = (text: string, options?: ITextFormatOptions) => {\n\tif (!text) {\n\t\treturn text;\n\t}\n\ttext = formatByOptions(text, options);\n\treturn text.split(' ').map(word => firstLetterToUpperCase(word)).join(' ');\n};\n\nexport const firstLetterToUpperCase = (text: string, options?: ITextFormatOptions) => {\n\tif (!text) {\n\t\treturn text;\n\t}\n\treturn uppercaseByPosition(text, 0, options);\n};\n\nexport const uppercaseByPosition = (text: string, position: number, options?: ITextFormatOptions) => {\n\tif (!text) {\n\t\treturn text;\n\t}\n\ttext = formatByOptions(text, options);\n\treturn `${text.substring(0, position)}${text.charAt(position).toUpperCase()}${text.substring(position + 1)}`;\n};\n\nconst formatByOptions = (text: string, options?: ITextFormatOptions) => {\n\tif (!text || !options) {\n\t\treturn text;\n\t}\n\tif (options?.uppercaseOtherCharacter) {\n\t\ttext = text.toUpperCase();\n\t}\n\n\tif (options?.lowercaseOtherCharacter) {\n\t\ttext = text.toLowerCase();\n\t}\n\n\tif (options?.removeMultipleSpace) {\n\t\ttext = text.replace(/\\u200B|\\u00A0/g, \"\");\n\t\ttext = text.replace(/\\s+/g, ' ');\n\t}\n\n\tif (options?.removeEmoji) {\n\t\ttext = removeEmoji(text);\n\t}\n\n\tif (options?.removeUnicode) {\n\t\ttext = deleteUnicode(text);\n\t}\n\n\tif (options?.trim) {\n\t\ttext = text.trim();\n\t}\n\n\treturn text;\n};\n\nexport const escapeHtml = (str: string): string => {\n\tif (!str || typeof str !== 'string') {\n\t\treturn str;\n\t}\n\n\treturn str\n\t\t.replace(/&/g, \"&amp;\")\n\t\t.replace(/</g, \"&lt;\")\n\t\t.replace(/>/g, \"&gt;\")\n\t\t.replace(/\"/g, \"&quot;\")\n\t\t.replace(/'/g, \"&#039;\");\n};\n\nexport const decodeEscapeHtml = (str: string): string => {\n\tconst htmlTag = document.createElement('textarea');\n\n\thtmlTag.innerHTML = str;\n\twhile (str) {\n\t\tif (str === htmlTag.value) {\n\t\t\tstr = htmlTag.value;\n\t\t\thtmlTag.remove();\n\t\t\tbreak;\n\t\t}\n\t\tstr = htmlTag.value;\n\t\thtmlTag.innerHTML = str;\n\t}\n\n\treturn str;\n};\n\nexport const deleteUnicode = (str: string) => {\n\tstr = str.replace(/à|á|ạ|ả|ã|â|ầ|ấ|ậ|ẩ|ẫ|ă|ằ|ắ|ặ|ẳ|ẵ/g, 'a');\n\tstr = str.replace(/è|é|ẹ|ẻ|ẽ|ê|ề|ế|ệ|ể|ễ|ễ/g, 'e');\n\tstr = str.replace(/ì|í|ị|ỉ|ĩ/g, 'i');\n\tstr = str.replace(/ò|ó|ọ|ỏ|õ|ô|ồ|ố|ộ|ổ|ỗ|ơ|ờ|ớ|ợ|ở|ỡ/g, 'o');\n\tstr = str.replace(/ù|ú|ụ|ủ|ũ|ư|ừ|ứ|ự|ử|ữ/g, 'u');\n\tstr = str.replace(/ỳ|ý|ỵ|ỷ|ỹ/g, 'y');\n\tstr = str.replace(/đ/g, 'd');\n\tstr = str.replace(/À|Á|Ạ|Ả|Ã|Â|Ầ|Ấ|Ậ|Ẩ|Ẫ|Ă|Ằ|Ắ|Ặ|Ẳ|Ẵ/g, 'A');\n\tstr = str.replace(/È|É|Ẹ|Ẻ|Ẽ|Ê|Ề|Ế|Ệ|Ể|Ễ/g, 'E');\n\tstr = str.replace(/Ì|Í|Ị|Ỉ|Ĩ/g, 'I');\n\tstr = str.replace(/Ò|Ó|Ọ|Ỏ|Õ|Ô|Ồ|Ố|Ộ|Ổ|Ỗ|Ơ|Ờ|Ớ|Ợ|Ở|Ỡ/g, 'O');\n\tstr = str.replace(/Ù|Ú|Ụ|Ủ|Ũ|Ư|Ừ|Ứ|Ự|Ử|Ữ/g, 'U');\n\tstr = str.replace(/Ỳ|Ý|Ỵ|Ỷ|Ỹ/g, 'Y');\n\tstr = str.replace(/Đ/g, 'D');\n\n\tstr = str.replace(/\\u0300|\\u0301|\\u0303|\\u0309|\\u0323/g, \"\"); // ̀ ́ ̃ ̉ ̣  huyền, sắc, ngã, hỏi, nặng\n\tstr = str.replace(/\\u02C6|\\u0306|\\u031B/g, \"\"); // ˆ ̆ ̛  Â, Ê, Ă, Ơ, Ư\n\n\treturn str.normalize(\"NFC\");\n};\n\nexport const removeEmoji = (text: string) => {\n\tif (!text || !text.trim()) {\n\t\treturn text;\n\t}\n\n\treturn text.replace(patternEmoji(), '');\n};"]}

package/esm2022/get-smart-axis-scale.mjs

@@ -0,0 +1,174 @@
+import { isNil } from "./helpers";
+const DEFAULT_MIN_TICK_COUNT = 5;
+const DEFAULT_MAX_TICK_COUNT = 10;
+const MIN_DISTANCE_TO_ZERO = 3;
+const NEGATIVE_THRESHOLD = -5;
+const FALLBACK_NEGATIVE_VALUE = -4;
+const MAX_POW_NUMBER = 14;
+const MAX_TEMPLATE_NUMBER = 10;
+/**
+ * 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 const getSmartAxisScale = (originalMaxData, options) => {
+    let maxData = originalMaxData;
+    validateInputs(maxData, options);
+    const minTickCount = options?.minTickCount || DEFAULT_MIN_TICK_COUNT;
+    const maxTickCount = options?.maxTickCount || DEFAULT_MAX_TICK_COUNT;
+    let scaleDirection = 1;
+    let rangeDistance = maxData;
+    if (options?.acceptNegative && !isNil(options.minNegative)) {
+        if (maxData === 0) {
+            maxData = -1;
+        }
+        if (maxData <= 0) {
+            rangeDistance = options.minNegative;
+        }
+        if (rangeDistance > NEGATIVE_THRESHOLD) {
+            rangeDistance = FALLBACK_NEGATIVE_VALUE;
+        }
+        if (maxData > 0) {
+            rangeDistance = maxData + Math.abs(options.minNegative);
+            scaleDirection = -1;
+        }
+    }
+    if (Math.abs(rangeDistance) < MIN_DISTANCE_TO_ZERO) {
+        rangeDistance = MIN_DISTANCE_TO_ZERO;
+    }
+    const stepCandidates = getStepCandidates(maxData, minTickCount, options?.minNegative || 0, options?.acceptStepIsTypeFloat, options?.stepCandidates, options?.acceptNegative);
+    for (const step of stepCandidates) {
+        let tickCount = Math.abs(Math.ceil(rangeDistance / step)) + (scaleDirection === -1 ? 2 : 1);
+        let maxValue = maxData <= 0 ? 0 : step * tickCount * scaleDirection;
+        let minValue = 0;
+        if (tickCount >= minTickCount && tickCount <= maxTickCount) {
+            if (maxData < maxValue) {
+                if (options?.acceptNegative) {
+                    let tick = 1;
+                    while (!isNil(options.minNegative) && tick <= tickCount && minValue >= options.minNegative) {
+                        minValue = tick * step;
+                        tick++;
+                    }
+                }
+                const maxValuePositive = maxValue - Math.abs(minValue);
+                tickCount = maxValuePositive - originalMaxData > Math.abs(step) && tickCount - 1 >= minTickCount ? tickCount - 1 : tickCount;
+                maxValue = (step * tickCount * scaleDirection) - (minValue * scaleDirection);
+                return {
+                    stepSize: Math.abs(step),
+                    max: maxValue,
+                    min: minValue,
+                    tickAmount: tickCount
+                };
+            }
+        }
+    }
+    let step = Math.ceil(rangeDistance / minTickCount) || 1;
+    let maxValue = step * minTickCount;
+    if (rangeDistance === maxValue) {
+        step = step + Math.ceil(step / 10);
+        maxValue = step * minTickCount;
+    }
+    return {
+        stepSize: Math.abs(step),
+        max: maxValue,
+        min: 0,
+        tickAmount: minTickCount
+    };
+};
+// Cache cho các giá trị lũy thừa 10 để tối ưu hiệu suất
+const POWER_CACHE = new Map();
+/**
+ * Tạo danh sách các step candidates cho việc tính toán scale
+ * @param maxData - Giá trị dữ liệu tối đa
+ * @param minStep - Số bước tối thiểu
+ * @param minNegative - Giá trị âm tối thiểu
+ * @param acceptStepIsTypeFloat - Có chấp nhận step thập phân không
+ * @param stepCandidatesByOptions - Step candidates do người dùng cung cấp
+ * @param includeNegativeSteps - Có bao gồm các step âm không
+ * @returns Danh sách các step candidates
+ */
+const getStepCandidates = (maxData, minStep, minNegative, acceptStepIsTypeFloat = false, stepCandidatesByOptions, includeNegativeSteps = false) => {
+    // Nếu có step candidates tùy chỉnh, sử dụng chúng
+    if (stepCandidatesByOptions && stepCandidatesByOptions.length > 0) {
+        return stepCandidatesByOptions;
+    }
+    const stepCandidates = new Array();
+    const maxValueStep = Math.abs(Math.max(maxData, Math.abs(minNegative || 0))) / minStep;
+    // Tạo step candidates dựa trên lũy thừa của 10
+    for (let powNumber = 0; powNumber <= MAX_POW_NUMBER; powNumber++) {
+        // Sử dụng cache để tối ưu hiệu suất
+        if (!POWER_CACHE.has(powNumber)) {
+            POWER_CACHE.set(powNumber, Math.pow(10, powNumber));
+        }
+        const powValue = POWER_CACHE.get(powNumber);
+        for (let templateNumber = 1; templateNumber < MAX_TEMPLATE_NUMBER; templateNumber++) {
+            // Thêm step thập phân nếu được chấp nhận
+            if (acceptStepIsTypeFloat) {
+                const step = powValue * (((templateNumber - 1) * 2 + 1) / 2);
+                stepCandidates.push(step);
+            }
+            const step = powValue * templateNumber;
+            stepCandidates.push(step);
+            // Dừng khi step đã đủ lớn
+            if (step >= maxValueStep) {
+                checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);
+                return stepCandidates;
+            }
+        }
+    }
+    checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);
+    return stepCandidates;
+};
+/**
+ * Kiểm tra và thêm các step âm vào danh sách candidates nếu cần
+ * @param stepCandidates - Danh sách step candidates hiện tại
+ * @param acceptNegative - Có chấp nhận giá trị âm không
+ * @param minNegative - Giá trị âm tối thiểu
+ */
+const checkAndSetNegativeSteps = (stepCandidates, acceptNegative, minNegative) => {
+    if (acceptNegative && minNegative < 0) {
+        // Tạo các step âm và thêm vào đầu danh sách
+        const negativeSteps = [...stepCandidates].map(step => -step);
+        stepCandidates.unshift(...negativeSteps);
+    }
+};
+/**
+ * Kiểm tra tính hợp lệ của các tham số đầu vào
+ * @param maxData - Giá trị dữ liệu tối đa
+ * @param options - Các tùy chọn cấu hình
+ * @throws {Error} Khi các tham số không hợp lệ
+ */
+const validateInputs = (maxData, options) => {
+    // Kiểm tra maxData âm khi không chấp nhận giá trị âm
+    if (maxData < 0 && !options?.acceptNegative) {
+        throw new Error("maxData is less than 0 and acceptNegative is false");
+    }
+    if (options?.acceptNegative) {
+        // Kiểm tra minNegative có được cung cấp không
+        if (isNil(options.minNegative)) {
+            throw new Error("minNegative is required when acceptNegative is true");
+        }
+        // Kiểm tra maxData phải >= minNegative
+        if (maxData < options.minNegative) {
+            throw new Error("maxData is less than minNegative");
+        }
+        // Kiểm tra minNegative phải là số âm
+        if (options.minNegative >= 0) {
+            throw new Error("minNegative must be negative");
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-smart-axis-scale.js","sourceRoot":"","sources":["../../../../libs-ui/utils/src/get-smart-axis-scale.ts"],"names":[],"mappings":"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","sourcesContent":["import { isNil } from \"./helpers\";\nconst DEFAULT_MIN_TICK_COUNT = 5;\nconst DEFAULT_MAX_TICK_COUNT = 10;\nconst MIN_DISTANCE_TO_ZERO = 3;\nconst NEGATIVE_THRESHOLD = -5;\nconst FALLBACK_NEGATIVE_VALUE = -4;\nconst MAX_POW_NUMBER = 14;\nconst MAX_TEMPLATE_NUMBER = 10;\n\n// ✅ Thêm interfaces để tăng cường type safety\ninterface AxisScaleOptions {\n  minTickCount?: number; // Số lượng tick tối thiểu\n  maxTickCount?: number; // Số lượng tick tối đa\n  stepCandidates?: number[]; // Danh sách các step candidates tùy chỉnh\n  acceptNegative?: boolean; // Có chấp nhận giá trị âm không\n  minNegative?: number; // Giá trị âm tối thiểu\n  acceptStepIsTypeFloat?: boolean; // Có chấp nhận step là số thập phân không\n}\n\ninterface AxisScaleResult {\n  stepSize: number; // Kích thước bước\n  max: number; // Giá trị tối đa của trục\n  min: number; // Giá trị tối thiểu của trục\n  tickAmount: number; // Số lượng tick\n}\n\n/**\n * Tính toán smart axis scale cho biểu đồ\n * \n * @param maxData - Giá trị tối đa của dữ liệu\n * @param options - Các tùy chọn cấu hình axis scale\n * @returns Cấu hình axis scale bao gồm stepSize, max, min, tickAmount\n * \n * @throws {Error} INVALID_NEGATIVE_DATA - khi maxData < 0 mà acceptNegative = false\n * @throws {Error} MISSING_MIN_NEGATIVE - khi acceptNegative = true nhưng thiếu minNegative\n * @throws {Error} INVALID_RANGE - khi maxData < minNegative\n * @throws {Error} INVALID_MIN_NEGATIVE - khi minNegative >= 0\n * \n * @example\n * ```typescript\n * const result = getSmartAxisScale(100, { minTickCount: 5, maxTickCount: 10 });\n * // returns { stepSize: 20, max: 120, min: 0, tickAmount: 6 }\n * ```\n */\nexport const getSmartAxisScale = (originalMaxData: number, options?: AxisScaleOptions): AxisScaleResult => {\n  let maxData = originalMaxData;\n  \n  validateInputs(maxData, options);\n  const minTickCount = options?.minTickCount || DEFAULT_MIN_TICK_COUNT;\n  const maxTickCount = options?.maxTickCount || DEFAULT_MAX_TICK_COUNT;\n  \n  let scaleDirection = 1;\n  let rangeDistance = maxData;\n  \n  \n  if (options?.acceptNegative && !isNil(options.minNegative)) {\n    if (maxData === 0) {\n      maxData = -1;\n    }\n    if (maxData <= 0) {\n      rangeDistance = options.minNegative;\n    }\n    if (rangeDistance > NEGATIVE_THRESHOLD) {\n      rangeDistance = FALLBACK_NEGATIVE_VALUE;\n    }\n    if (maxData > 0) {\n      rangeDistance = maxData + Math.abs(options.minNegative);\n      scaleDirection = -1;\n    }\n  }\n  if (Math.abs(rangeDistance) < MIN_DISTANCE_TO_ZERO) {\n    rangeDistance = MIN_DISTANCE_TO_ZERO;\n  }\n  \n  const stepCandidates = getStepCandidates(\n    maxData,\n    minTickCount,\n    options?.minNegative || 0,\n    options?.acceptStepIsTypeFloat,\n    options?.stepCandidates,\n    options?.acceptNegative\n  );\n  for (const step of stepCandidates) {\n    let tickCount = Math.abs(Math.ceil(rangeDistance / step)) + (scaleDirection === -1 ? 2 : 1);\n    let maxValue = maxData <= 0 ? 0 : step * tickCount * scaleDirection;\n    let minValue = 0;\n\n    if (tickCount >= minTickCount && tickCount <= maxTickCount) {\n      if (maxData < maxValue) {\n        if (options?.acceptNegative) {\n          let tick = 1;\n          while (!isNil(options.minNegative) && tick <= tickCount && minValue >= options.minNegative) {\n            minValue = tick * step;\n            tick++;\n          }\n        }\n        const maxValuePositive = maxValue - Math.abs(minValue);\n        tickCount = maxValuePositive - originalMaxData > Math.abs(step) && tickCount - 1 >= minTickCount ? tickCount - 1 : tickCount;\n\n        maxValue = (step * tickCount * scaleDirection) - (minValue * scaleDirection);\n        return {\n          stepSize: Math.abs(step),\n          max: maxValue,\n          min: minValue,\n          tickAmount: tickCount\n        };\n      }\n    }\n  }\n\n  let step = Math.ceil(rangeDistance / minTickCount) || 1;\n  let maxValue = step * minTickCount;\n  if (rangeDistance === maxValue) {\n    step = step + Math.ceil(step / 10);\n    maxValue = step * minTickCount;\n  }\n  return {\n    stepSize: Math.abs(step),\n    max: maxValue,\n    min: 0,\n    tickAmount: minTickCount\n  };\n}\n\n// Cache cho các giá trị lũy thừa 10 để tối ưu hiệu suất\nconst POWER_CACHE = new Map<number, number>();\n\n/**\n * Tạo danh sách các step candidates cho việc tính toán scale\n * @param maxData - Giá trị dữ liệu tối đa\n * @param minStep - Số bước tối thiểu\n * @param minNegative - Giá trị âm tối thiểu\n * @param acceptStepIsTypeFloat - Có chấp nhận step thập phân không\n * @param stepCandidatesByOptions - Step candidates do người dùng cung cấp\n * @param includeNegativeSteps - Có bao gồm các step âm không\n * @returns Danh sách các step candidates\n */\nconst getStepCandidates = (\n  maxData: number,\n  minStep: number,\n  minNegative: number,\n  acceptStepIsTypeFloat = false,\n  stepCandidatesByOptions?: number[],\n  includeNegativeSteps = false\n): number[] => {\n  // Nếu có step candidates tùy chỉnh, sử dụng chúng\n  if(stepCandidatesByOptions && stepCandidatesByOptions.length > 0){\n    return stepCandidatesByOptions;\n  }\n  \n  const stepCandidates= new Array<number>();\n  const maxValueStep = Math.abs(Math.max(maxData, Math.abs(minNegative || 0))) / minStep;\n\n  // Tạo step candidates dựa trên lũy thừa của 10\n  for (let powNumber = 0; powNumber <= MAX_POW_NUMBER; powNumber++) {\n    // Sử dụng cache để tối ưu hiệu suất\n    if(!POWER_CACHE.has(powNumber)){\n      POWER_CACHE.set(powNumber,Math.pow(10,powNumber));\n    }\n    const powValue = POWER_CACHE.get(powNumber) as number;\n    \n    for (let templateNumber = 1; templateNumber < MAX_TEMPLATE_NUMBER; templateNumber++) {\n      // Thêm step thập phân nếu được chấp nhận\n      if (acceptStepIsTypeFloat) {\n        const step = powValue * (((templateNumber - 1) * 2 + 1) / 2);\n        stepCandidates.push(step);\n      }\n      \n      const step = powValue * templateNumber;\n      stepCandidates.push(step);\n\n      // Dừng khi step đã đủ lớn\n      if (step >= maxValueStep) {\n        checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);\n        return stepCandidates;\n      }\n    }\n  }\n  \n  checkAndSetNegativeSteps(stepCandidates, includeNegativeSteps, minNegative);\n  return stepCandidates;\n}\n\n/**\n * Kiểm tra và thêm các step âm vào danh sách candidates nếu cần\n * @param stepCandidates - Danh sách step candidates hiện tại\n * @param acceptNegative - Có chấp nhận giá trị âm không\n * @param minNegative - Giá trị âm tối thiểu\n */\nconst checkAndSetNegativeSteps = (stepCandidates: number[], acceptNegative: boolean, minNegative: number): void => {\n  if (acceptNegative && minNegative < 0) {\n    // Tạo các step âm và thêm vào đầu danh sách\n    const negativeSteps = [...stepCandidates].map(step => -step);\n    stepCandidates.unshift(...negativeSteps);\n  }\n} \n\n/**\n * Kiểm tra tính hợp lệ của các tham số đầu vào\n * @param maxData - Giá trị dữ liệu tối đa\n * @param options - Các tùy chọn cấu hình\n * @throws {Error} Khi các tham số không hợp lệ\n */\nconst validateInputs = (maxData: number, options?: AxisScaleOptions): void => {\n  // Kiểm tra maxData âm khi không chấp nhận giá trị âm\n  if (maxData < 0 && !options?.acceptNegative) {\n    throw new Error(\"maxData is less than 0 and acceptNegative is false\");\n  }\n  \n  if (options?.acceptNegative) {\n    // Kiểm tra minNegative có được cung cấp không\n    if (isNil(options.minNegative)) {\n      throw new Error(\"minNegative is required when acceptNegative is true\");\n    }\n\n    // Kiểm tra maxData phải >= minNegative\n    if (maxData < options.minNegative) {\n      throw new Error(\"maxData is less than minNegative\");\n    }\n\n    // Kiểm tra minNegative phải là số âm\n    if (options.minNegative >= 0) {\n      throw new Error(\"minNegative must be negative\");\n    }\n  }\n} "]}