@libs-ui/utils 0.2.283 → 0.2.285

package/fesm2022/libs-ui-utils.mjs

@@ -2511,8 +2511,6 @@ const convertUrlToFile = (url, fileName) => {
     });
 };
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-// Constants for better maintainability
 const DEFAULT_MIN_TICK_COUNT = 5;
 const DEFAULT_MAX_TICK_COUNT = 10;
 const MIN_DISTANCE_TO_ZERO = 3;
@@ -2520,144 +2518,78 @@ const NEGATIVE_THRESHOLD = -5;
 const FALLBACK_NEGATIVE_VALUE = -4;
 const MAX_POW_NUMBER = 14;
 const MAX_TEMPLATE_NUMBER = 10;
-// Cache for power calculations - shared across function calls for better performance
-const POWER_CACHE = new Map();
 /**
- * Calculates smart axis scale for charts
+ * 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
  *
- * @description This function can throw errors if:
- * - maxData < 0 and acceptNegative is false
- * - minNegative is undefined and acceptNegative is true
- * - maxData < minNegative (only when acceptNegative is true)
- * - minNegative > 0 (only when acceptNegative is true)
+ * @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
  *
- * @throws {Error} Validation errors for invalid input combinations
- * @required Always wrap this function in try-catch and handle exceptions
- * @param maxData - Maximum data value
- * @param options - Configuration options for axis scaling
- * @returns Axis scale configuration
+ * @example
+ * ```typescript
+ * const result = getSmartAxisScale(100, { minTickCount: 5, maxTickCount: 10 });
+ * // returns { stepSize: 20, max: 120, min: 0, tickAmount: 6 }
+ * ```
  */
-const getSmartAxisScale = (maxData, options) => {
-    // Input validation - fail fast approach
+const getSmartAxisScale = (originalMaxData, options) => {
+    let maxData = originalMaxData;
     validateInputs(maxData, options);
-    // Extract and set defaults
-    const { minTickCount = DEFAULT_MIN_TICK_COUNT, maxTickCount = DEFAULT_MAX_TICK_COUNT, stepCandidates = [], acceptNegative = false, minNegative, acceptStepIsTypeFloat = false } = options || {};
-    // Generate step candidates if not provided
-    const finalStepCandidates = stepCandidates.length > 0
-        ? [...stepCandidates]
-        : generateStepCandidates(maxData, minTickCount, minNegative, acceptStepIsTypeFloat);
-    // Remove console.log for production code
-    // console.log(`stepCandidates: `, finalStepCandidates);
-    // Calculate scale parameters
-    const scaleParams = calculateScaleParams(maxData, acceptNegative, minNegative, finalStepCandidates);
-    // Find optimal scale
-    const optimalScale = findOptimalScale(scaleParams, finalStepCandidates, minTickCount, maxTickCount, options);
-    if (optimalScale) {
-        return optimalScale;
-    }
-    // Fallback calculation
-    return calculateFallbackScale(scaleParams.distanceToZero, minTickCount);
-};
-/**
- * Validates input parameters
- */
-function validateInputs(maxData, options) {
-    if (maxData < 0 && !options?.acceptNegative) {
-        throw new Error("maxData is less than 0 and acceptNegative is false");
-    }
-    if (options?.acceptNegative) {
-        if (isNil(options.minNegative)) {
-            throw new Error("minNegative is required when acceptNegative is true");
-        }
-        if (maxData < options.minNegative) {
-            throw new Error("maxData is less than minNegative");
-        }
-        if (options.minNegative >= 0) {
-            throw new Error("minNegative must be negative");
-        }
-    }
-}
-/**
- * Calculates scale parameters for axis calculation
- */
-function calculateScaleParams(maxData, acceptNegative, minNegative, stepCandidates) {
-    let distanceToZero = maxData;
-    let reverse = 1;
-    let adjustedMaxData = maxData;
-    if (acceptNegative && !isNil(minNegative)) {
+    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) {
-            adjustedMaxData = -1;
-        }
-        // Add negative step candidates
-        if (stepCandidates) {
-            stepCandidates.unshift(...stepCandidates.map(item => -item));
+            maxData = -1;
         }
-        if (adjustedMaxData <= 0) {
-            distanceToZero = minNegative;
+        if (maxData <= 0) {
+            rangeDistance = options.minNegative;
         }
-        if (distanceToZero > NEGATIVE_THRESHOLD) {
-            distanceToZero = FALLBACK_NEGATIVE_VALUE;
+        if (rangeDistance > NEGATIVE_THRESHOLD) {
+            rangeDistance = FALLBACK_NEGATIVE_VALUE;
         }
-        if (adjustedMaxData > 0) {
-            distanceToZero = adjustedMaxData + Math.abs(minNegative);
-            reverse = -1;
+        if (maxData > 0) {
+            rangeDistance = maxData + Math.abs(options.minNegative);
+            scaleDirection = -1;
         }
     }
-    if (Math.abs(distanceToZero) < MIN_DISTANCE_TO_ZERO) {
-        distanceToZero = MIN_DISTANCE_TO_ZERO;
+    if (Math.abs(rangeDistance) < MIN_DISTANCE_TO_ZERO) {
+        rangeDistance = MIN_DISTANCE_TO_ZERO;
     }
-    return { distanceToZero, reverse, adjustedMaxData };
-}
-/**
- * Finds optimal scale from step candidates
- */
-function findOptimalScale(scaleParams, stepCandidates, minTickCount, maxTickCount, options) {
-    const { distanceToZero, reverse, adjustedMaxData } = scaleParams;
+    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(distanceToZero / step)) + (reverse === -1 ? 2 : 1);
-        let maxValue = adjustedMaxData <= 0 ? 0 : step * tickCount * reverse;
+        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 && adjustedMaxData < maxValue) {
-            if (options?.acceptNegative) {
-                minValue = calculateMinValue(step, tickCount, options.minNegative);
-            }
-            // Adjust tick count based on distance calculation
-            const distanceCheck = distanceToZero - (tickCount - 1) * step;
-            if (distanceCheck < -1 * (step / 4)) {
-                tickCount -= 1;
+        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
+                };
             }
-            maxValue = (step * tickCount * reverse) - (minValue * reverse);
-            return {
-                stepSize: Math.abs(step),
-                max: maxValue,
-                min: minValue,
-                tickAmount: tickCount
-            };
-        }
-    }
-    return null;
-}
-/**
- * Calculates minimum value for negative acceptance
- */
-function calculateMinValue(step, tickCount, minNegative) {
-    let minValue = 0;
-    if (!isNil(minNegative)) {
-        let tick = 1;
-        while (tick <= tickCount && minValue >= minNegative) {
-            minValue = tick * step;
-            tick++;
         }
     }
-    return minValue;
-}
-/**
- * Calculates fallback scale when no optimal scale is found
- */
-function calculateFallbackScale(distanceToZero, minTickCount) {
-    let step = Math.ceil(distanceToZero / minTickCount) || 1;
+    let step = Math.ceil(rangeDistance / minTickCount) || 1;
     let maxValue = step * minTickCount;
-    if (distanceToZero === maxValue) {
+    if (rangeDistance === maxValue) {
         step = step + Math.ceil(step / 10);
         maxValue = step * minTickCount;
     }
@@ -2667,34 +2599,90 @@ function calculateFallbackScale(distanceToZero, minTickCount) {
         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();
 /**
- * Generates step candidates with performance optimizations
+ * 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
  */
-function generateStepCandidates(maxData, minStep, minNegative, acceptStepIsTypeFloat) {
-    const stepCandidates = [];
+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;
-    // Pre-populate power cache for better performance
-    for (let powNumber = 0; powNumber < MAX_POW_NUMBER; powNumber++) {
+    // 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 powByTemp = POWER_CACHE.get(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 floatStep = powByTemp * (((templateNumber - 1) * 2 + 1) / 2);
-                stepCandidates.push(floatStep);
+                const step = powValue * (((templateNumber - 1) * 2 + 1) / 2);
+                stepCandidates.push(step);
             }
-            const step = powByTemp * templateNumber;
+            const step = powValue * templateNumber;
             stepCandidates.push(step);
-            // Early termination for performance
+            // 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");
+        }
+    }
+};
 
 /**
  * Generated bundle index. Do not edit.